jazz-tools 0.7.0-alpha.0 → 0.7.0-alpha.11

package/src/coValues/coMap/coMapOf.ts

@@ -1,451 +0,0 @@
-import {
-    ID,
-    isCoValueSchema,
-    isCoValue,
-    CoValue,
-    inspect,
-    CoValueSchema,
-} from "../../coValueInterfaces.js";
-import {
-    CoMapFields,
-    CoMapInit,
-    CoMapSchema,
-    CoMap,
-    IndexSignature,
-    CoMapBase,
-    NoIndexSignature,
-} from "./coMap.js";
-import { ValueRef, makeRefs } from "../../refs.js";
-import { JsonValue, RawAccount, RawCoMap, cojsonInternals } from "cojson";
-import { AnyGroup } from "../group/group.js";
-import { AnyAccount, ControlledAccount } from "../account/account.js";
-import { Account, controlledAccountFromNode } from "../account/accountOf.js";
-import { subscriptionsScopes } from "../../subscriptionScope.js";
-import { AST, Schema } from "@effect/schema";
-import {
-    constructorOfSchemaSym,
-    propertyIsCoValueSchema,
-} from "../resolution.js";
-import { JsonObject } from "cojson/src/jsonValue.js";
-import { SharedCoValueConstructor } from "../construction.js";
-import {
-    PropertySignatureWithOutput,
-    propSigToSchema,
-} from "../../schemaHelpers.js";
-import { pipeArguments } from "effect/Pipeable";
-import { Group } from "../group/groupOf.js";
-
-export function CoMapOf<
-    Fields extends CoMapFields,
-    IndexSig extends IndexSignature = NoIndexSignature,
->(fields: Fields, indexSignature?: IndexSig) {
-    class CoMapOfFields
-        extends SharedCoValueConstructor
-        implements CoMapBase<Fields, IndexSig>
-    {
-        static get ast() {
-            return AST.setAnnotation(
-                Schema.instanceOf(this).ast,
-                constructorOfSchemaSym,
-                this
-            );
-        }
-        static [Schema.TypeId]: Schema.Schema.Variance<
-            CoMapOfFields,
-            CoMapOfFields,
-            never
-        >[Schema.TypeId];
-        static pipe() {
-            // eslint-disable-next-line prefer-rest-params
-            return pipeArguments(this, arguments);
-        }
-        static type = "CoMap" as const;
-
-        id!: ID<this>;
-        _type!: "CoMap";
-        _owner!: AnyAccount | AnyGroup;
-        _refs!: CoMapBase<Fields, IndexSig>["_refs"];
-        _edits!: CoMapBase<Fields, IndexSig>["_edits"];
-        _raw!: RawCoMap;
-        _loadedAs!: ControlledAccount;
-        _schema!: typeof CoMapOfFields;
-
-        constructor(_init: undefined, options: { fromRaw: RawCoMap });
-        constructor(
-            init: CoMapInit<Fields>,
-            options: { owner: AnyAccount | AnyGroup }
-        );
-        constructor(
-            init: CoMapInit<Fields> | undefined,
-            options: { owner: AnyAccount | AnyGroup } | { fromRaw: RawCoMap }
-        ) {
-            super();
-
-            let raw: RawCoMap;
-
-            if ("fromRaw" in options) {
-                raw = options.fromRaw;
-            } else {
-                const rawOwner = options.owner._raw;
-
-                const rawInit = {} as {
-                    [key in keyof CoMapInit<Fields>]: JsonValue | undefined;
-                };
-
-                if (init)
-                    for (const key of Object.keys(
-                        init
-                    ) as (keyof CoMapInit<Fields>)[]) {
-                        const initValue = init[key];
-                        const field =
-                            fields[key] ||
-                            (indexSignature &&
-                                Schema.is(indexSignature.key)(key) &&
-                                indexSignature.value);
-
-                        if (!field) {
-                            throw new Error(`Key ${String(key)} not in schema`);
-                        }
-
-                        if (propertyIsCoValueSchema(field)) {
-                            // TOOD: check for alignment of actual value with schema
-                            if (isCoValue(initValue)) {
-                                rawInit[key] = initValue.id;
-                            } else {
-                                throw new Error(
-                                    `Expected covalue in ${String(
-                                        key
-                                    )} but got ${initValue}`
-                                );
-                            }
-                        } else {
-                            const fieldSchema = (
-                                "propertySignatureAST" in field
-                                    ? Schema.make<JsonObject, any, never>(
-                                          (
-                                              field.propertySignatureAST as {
-                                                  from: AST.AST;
-                                              }
-                                          ).from
-                                      )
-                                    : field
-                            ) as Schema.Schema<JsonObject, any, never>;
-                            rawInit[key] =
-                                Schema.encodeSync(fieldSchema)(initValue);
-                        }
-                    }
-
-                raw = rawOwner.createMap(rawInit);
-            }
-
-            for (const key of Object.keys(fields) as (keyof Fields)[]) {
-                if (typeof key !== "string") continue;
-
-                const fieldSchema = fields[key]!;
-                if (propertyIsCoValueSchema(fieldSchema)) {
-                    Object.defineProperty(this, key, {
-                        get(this: CoMapOfFields) {
-                            return this.getCoValueAtKey(key);
-                        },
-                        set(this: CoMapOfFields, value) {
-                            this.setCoValueAtKey(key, value);
-                        },
-                        enumerable: true,
-                    });
-                } else {
-                    Object.defineProperty(this, key, {
-                        get(this: CoMapOfFields) {
-                            return this.getPrimitiveAtKey(key, fieldSchema);
-                        },
-                        set(this: CoMapOfFields, value) {
-                            this.setPrimitiveAtKey(key, value, fieldSchema);
-                        },
-                        enumerable: true,
-                    });
-                }
-            }
-
-            const fieldsThatAreRefs = Object.entries(fields)
-                .filter(([_, value]) => isCoValueSchema(value))
-                .map(([key]) => key);
-
-            const refs = makeRefs<
-                {
-                    [Key in keyof Fields]: Fields[Key] extends CoValueSchema
-                        ? Exclude<Schema.Schema.To<Fields[Key]>, undefined>
-                        : never;
-                } & {
-                    [Key in Schema.Schema.To<IndexSig["key"]>]: Exclude<
-                        Schema.Schema.To<IndexSig["value"]>,
-                        undefined
-                    >;
-                }
-            >(
-                (key) => {
-                    return raw.get(key as string) as
-                        | ID<
-                              Schema.Schema.To<
-                                  Fields[typeof key] & CoValueSchema
-                              >
-                          >
-                        | undefined;
-                },
-                () => {
-                    if (indexSignature) {
-                        return raw
-                            .keys()
-                            .filter(
-                                (key) =>
-                                    fieldsThatAreRefs.includes(key) ||
-                                    Schema.is(indexSignature.key)(key)
-                            );
-                    } else {
-                        return fieldsThatAreRefs;
-                    }
-                },
-                controlledAccountFromNode(raw.core.node),
-                (key) =>
-                    fields[key] ||
-                    (indexSignature
-                        ? indexSignature.value
-                        : (() => {
-                              throw new Error(
-                                  "Expected " + String(key) + " to be valid"
-                              );
-                          })())
-            );
-
-            const getEdits = () =>
-                new Proxy(this, {
-                    get(target, key, receiver) {
-                        const schemaAtKey =
-                            fields[key as keyof Fields] ||
-                            (indexSignature &&
-                            Schema.is(indexSignature?.key)(key)
-                                ? indexSignature?.value
-                                : undefined);
-                        if (!schemaAtKey)
-                            return Reflect.get(target, key, receiver);
-
-                        const rawEdit = raw.lastEditAt(key as string);
-                        if (!rawEdit) return undefined;
-
-                        return {
-                            get value() {
-                                if (isCoValueSchema(schemaAtKey)) {
-                                    return this.ref?.accessFrom(target);
-                                } else {
-                                    return (
-                                        rawEdit?.value &&
-                                        Schema.decodeSync(
-                                            propSigToSchema(schemaAtKey)
-                                        )(rawEdit?.value)
-                                    );
-                                }
-                            },
-
-                            get ref() {
-                                if (isCoValueSchema(schemaAtKey)) {
-                                    return (
-                                        rawEdit?.value &&
-                                        new ValueRef(
-                                            rawEdit?.value as ID<CoValue>,
-                                            target._loadedAs,
-                                            schemaAtKey
-                                        )
-                                    );
-                                }
-                            },
-
-                            get by() {
-                                if (cojsonInternals.isAccountID(rawEdit.by)) {
-                                    return new ValueRef(
-                                        rawEdit.by as unknown as ID<AnyAccount>,
-                                        target._loadedAs,
-                                        Account
-                                    ).accessFrom(target);
-                                }
-                            },
-
-                            madeAt: rawEdit.at,
-                            tx: rawEdit.tx,
-                        };
-                    },
-                });
-
-            Object.defineProperties(this, {
-                id: {
-                    value: raw.id as unknown as ID<
-                        this & CoMap<Fields, IndexSig>
-                    >,
-                    enumerable: false,
-                },
-                _type: { value: "CoMap", enumerable: false },
-                _owner: {
-                    get: () =>
-                        raw.group instanceof RawAccount
-                            ? Account.fromRaw(raw.group)
-                            : Group.fromRaw(raw.group),
-                    enumerable: false,
-                },
-                _refs: { value: refs, enumerable: false },
-                _edits: { get: getEdits, enumerable: false },
-                _raw: { value: raw, enumerable: false },
-                _loadedAs: {
-                    get: () => controlledAccountFromNode(raw.core.node),
-                    enumerable: false,
-                },
-                _schema: {
-                    value: this.constructor,
-                    enumerable: false,
-                },
-            });
-
-            if (indexSignature) {
-                return new Proxy(this, {
-                    get(target, key) {
-                        if (key in target) {
-                            return Reflect.get(target, key);
-                        } else {
-                            if (Schema.is(indexSignature.key)(key as string)) {
-                                if (
-                                    propertyIsCoValueSchema(
-                                        indexSignature.value
-                                    )
-                                ) {
-                                    return target.getCoValueAtKey(
-                                        key as string
-                                    );
-                                } else {
-                                    return target.getPrimitiveAtKey(
-                                        key as string,
-                                        indexSignature.value
-                                    );
-                                }
-                            } else {
-                                throw new Error(
-                                    "No such key " + String(key) + " in CoMap"
-                                );
-                            }
-                        }
-                    },
-                    set(target, key, value) {
-                        if (key in target) {
-                            return Reflect.set(target, key, value);
-                        } else if (
-                            Schema.is(indexSignature.key)(key as string)
-                        ) {
-                            if (propertyIsCoValueSchema(indexSignature.value)) {
-                                target.setCoValueAtKey(key as string, value);
-                            } else {
-                                target.setPrimitiveAtKey(
-                                    key as string,
-                                    value,
-                                    indexSignature.value
-                                );
-                            }
-                            return true;
-                        } else {
-                            throw new Error(
-                                "No such key " + String(key) + " in CoMap"
-                            );
-                        }
-                    },
-                    ownKeys(target) {
-                        const keys = Reflect.ownKeys(target);
-                        for (const key of target._raw.keys()) {
-                            if (!keys.includes(key)) {
-                                if (
-                                    Schema.is(indexSignature.key)(key as string)
-                                ) {
-                                    keys.push(key);
-                                }
-                            }
-                        }
-                        return keys;
-                    },
-                    getOwnPropertyDescriptor(target, key) {
-                        if (key in target) {
-                            return Reflect.getOwnPropertyDescriptor(
-                                target,
-                                key
-                            );
-                        } else if (
-                            Schema.is(indexSignature.key)(key as string)
-                        ) {
-                            return {
-                                enumerable: true,
-                                configurable: true,
-                            };
-                        }
-                    },
-                });
-            }
-        }
-
-        static fromRaw(raw: RawCoMap): CoMapOfFields {
-            return new CoMapOfFields(undefined, { fromRaw: raw });
-        }
-
-        private getCoValueAtKey(key: string) {
-            return this._refs[key as keyof this["_refs"]]?.accessFrom(this);
-        }
-
-        private setCoValueAtKey(key: string, value: CoValue) {
-            this._raw.set(key, value.id);
-            subscriptionsScopes.get(this)?.onRefAccessedOrSet(value.id);
-        }
-
-        private getPrimitiveAtKey(
-            key: string,
-            schemaAtKey:
-                | Schema.Schema<any, JsonValue | undefined, never>
-                | PropertySignatureWithOutput<JsonValue | undefined>
-        ) {
-            return Schema.decodeSync(propSigToSchema(schemaAtKey))(
-                this._raw.get(key)
-            );
-        }
-
-        private setPrimitiveAtKey(
-            key: string,
-            value: any,
-            schemaAtKey:
-                | Schema.Schema<any, JsonValue | undefined, never>
-                | PropertySignatureWithOutput<JsonValue | undefined>
-        ) {
-            this._raw.set(
-                key,
-                Schema.encodeSync(propSigToSchema(schemaAtKey))(value) as
-                    | JsonValue
-                    | undefined
-            );
-        }
-
-        toJSON() {
-            return Object.fromEntries(
-                Object.entries(this).flatMap(([key, value]) =>
-                    typeof value === "object" && "toJSON" in value
-                        ? [[key, value?.toJSON()]]
-                        : [[key, value]]
-                )
-            );
-        }
-
-        [inspect]() {
-            return this.toJSON();
-        }
-
-        static as<SubClass>() {
-            return CoMapOfFields as unknown as CoMapSchema<
-                SubClass,
-                Fields,
-                IndexSig
-            >;
-        }
-    }
-
-    return CoMapOfFields as CoMapSchema<CoMapOfFields, Fields, IndexSig> & {
-        as<SubClass>(): CoMapSchema<SubClass, Fields, IndexSig>;
-    };
-}

package/src/coValues/coMap/internalDocs.ts

@@ -1 +0,0 @@
-export { CoMapBase, CoMapInit } from "./coMap.js";

package/src/coValues/coStream/coStream.ts

@@ -1,63 +0,0 @@
-import {
-    BinaryStreamInfo,
-    CojsonInternalTypes,
-    JsonValue,
-    RawBinaryCoStream,
-    RawCoStream,
-    SessionID,
-} from "cojson";
-import {
-    CoValue,
-    CoValueSchema,
-    ID,
-} from "../../coValueInterfaces.js";
-import { AnyAccount } from "../account/account.js";
-import { ValueRef } from "../../refs.js";
-import { SchemaWithOutput } from "../../schemaHelpers.js";
-import { Schema } from "@effect/schema";
-
-export type CoStreamEntry<Item extends SchemaWithOutput<CoValue> | SchemaWithOutput<JsonValue>> = {
-    value: Item extends CoValueSchema<infer Self> ? Self | undefined : Schema.Schema.To<Item>;
-    ref?: Item extends CoValueSchema<infer Self, infer Value> ? ValueRef<Self & Value> : never;
-    by?: AnyAccount;
-    madeAt: Date;
-    tx: CojsonInternalTypes.TransactionID;
-}
-
-export type CoStream<Item extends SchemaWithOutput<CoValue> | SchemaWithOutput<JsonValue>> =
-    CoValue<"CoStream", RawCoStream> & {
-        by: { [key: ID<AnyAccount>]: CoStreamEntry<Item>, me: CoStreamEntry<Item> };
-        in: { [key: SessionID]: CoStreamEntry<Item>, currentSession: CoStreamEntry<Item> };
-        push(...items: Schema.Schema.To<Item>[]): void;
-    };
-
-export interface CoStreamSchema<
-    Self,
-    Item extends CoValueSchema | SchemaWithOutput<JsonValue>,
-> extends CoValueSchema<
-        Self,
-        CoStream<Item>,
-        "CoStream",
-        Schema.Schema.To<Item>[]
-    > {}
-
-export interface BinaryCoStream
-    extends CoValue<"BinaryCoStream", RawBinaryCoStream> {
-    start(options: BinaryStreamInfo): void;
-    push(data: Uint8Array): void;
-    end(): void;
-    getChunks(options?: { allowUnfinished?: boolean }):
-        | (BinaryStreamInfo & {
-              chunks: Uint8Array[];
-              finished: boolean;
-          })
-        | undefined;
-}
-
-export interface BinaryCoStreamSchema
-    extends CoValueSchema<
-        BinaryCoStream,
-        BinaryCoStream,
-        "BinaryCoStream",
-        undefined
-    > {}