import { co, FileStream } from "jazz-tools";

const fileStream = await FileStream.createFromBlob(file, {owner: group})

// Create owned by an account
const stream = FileStream.create({ owner: myAccount });

// Create owned by a group
const stream = FileStream.create({ owner: teamGroup });

// Create with implicit owner
const stream = FileStream.create(myAccount);

class ColorFeed extends CoFeed.Of(co.string) {}
class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}

favDog.push("Poodle");
favDog.push("Schnowzer");

// Adds items to current session's log
feed.push("item1", "item2");

// View items from current session
console.log(feed.inCurrentSession);

// View aggregated items from all sessions for current account
console.log(feed.byMe);

class ColorList extends CoList.Of(
  co.string
) {}
class AnimalList extends CoList.Of(
  co.ref(Animal)
) {}

colorList[0];
colorList[3] = "yellow";
colorList.push("Kawazaki Green");
colorList.splice(1, 1);

animals._refs[0].id; // => ID<Animal>
animals._refs[0].value;
// => Animal | null
const animal = await animals._refs[0].load();

const colours = ColorList.create(
  ["red", "green", "blue"],
  { owner: me }
);
const animals = AnimalList.create(
  [cat, dog, fish],
  { owner: me }
);

const animalsWithVets =
  await ListOfAnimals.load(
    "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
    me,
    [{ vet: {} }]
  );

const unsub = ListOfAnimals.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  me,
  { vet: {} },
  (animalsWithVets) => console.log(animalsWithVets)
);

import { co, CoMap } from "jazz-tools";

class Person extends CoMap {
  name = co.string;
  age = co.number;
  pet = co.ref(Animal);
  car = co.ref(Car, { optional: true });
}

import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
 co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;

person.name;
person["age"];
person.age = 42;
person.pet?.name;
Object.keys(person);
// => ["name", "age", "pet"]

person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();

const person = Person.create({
  name: "Alice",
  age: 42,
  pet: cat,
}, { owner: friendGroup });

const person = await Person.load(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  { pet: {} }
);

const unsub = Person.subscribe(
  "co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
  { pet: {} },
  (person) => console.log(person)
);

import { SchemaUnion, CoMap } from "jazz-tools";

class BaseWidget extends CoMap {
  type = co.string;
}

class ButtonWidget extends BaseWidget {
  type = co.literal("button");
  label = co.string;
}

class SliderWidget extends BaseWidget {
  type = co.literal("slider");
  min = co.number;
  max = co.number;
}

const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
  switch (raw.get("type")) {
    case "button": return ButtonWidget;
    case "slider": return SliderWidget;
    default: throw new Error("Unknown widget type");
  }
});

const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
  switch (raw.get("type")) {
    case "button": return ButtonWidget;
    case "slider": return SliderWidget;
    default: throw new Error("Unknown widget type");
  }
});

const widget = await loadCoValue(WidgetUnion, id, me, {});

// You can narrow the returned instance to a subclass by using `instanceof`
if (widget instanceof ButtonWidget) {
  console.log(widget.label);
} else if (widget instanceof SliderWidget) {
  console.log(widget.min, widget.max);
}