cojson 0.4.1 → 0.4.6

package/src/queriedCoValues/queriedAccount.ts

@@ -1,40 +0,0 @@
-import { Account } from "../coValues/account.js";
-import { CoID, CoValue, ControlledAccount, InviteSecret } from "../index.js";
-import { QueryContext } from "../queries.js";
-import { QueriedGroup } from "./queriedGroup.js";
-
-export class QueriedAccount<A extends Account = Account> extends QueriedGroup<A> {
-    id!: CoID<A>;
-    isMe!: boolean;
-
-    constructor(account: A, queryContext: QueryContext) {
-        super(account, queryContext);
-        Object.defineProperties(this, {
-            id: { value: account.id, enumerable: false },
-            isMe: {
-                value: account.core.node.account.id === account.id,
-                enumerable: false,
-            },
-        });
-    }
-
-    createGroup() {
-        if (!this.isMe)
-            throw new Error("Only the current user can create a group");
-        return (
-            this.group.core.node.account as ControlledAccount
-        ).createGroup();
-    }
-
-    acceptInvite<T extends CoValue>(
-        groupOrOwnedValueID: CoID<T>,
-        inviteSecret: InviteSecret
-    ) {
-        if (!this.isMe)
-            throw new Error("Only the current user can accept an invite");
-        return (this.group.core.node.account as ControlledAccount).acceptInvite(
-            groupOrOwnedValueID,
-            inviteSecret
-        );
-    }
-}

package/src/queriedCoValues/queriedCoList.ts

@@ -1,240 +0,0 @@
-import { CoList, MutableCoList } from "../coValues/coList.js";
-import { CoValueCore } from "../coValueCore.js";
-import { Group } from "../coValues/group.js";
-import { CoID, CoValue } from "../coValue.js";
-import { TransactionID } from "../ids.js";
-import { ValueOrSubQueried, QueryContext } from "../queries.js";
-import { QueriedAccount } from "./queriedAccount.js";
-
-export class QueriedCoList<L extends CoList> extends Array<
-    ValueOrSubQueried<L["_item"]>
-> {
-    coList!: L;
-    id!: CoID<L>;
-    type!: "colist";
-
-    /** @internal */
-    constructor(coList: L, queryContext: QueryContext) {
-        if (!(coList instanceof CoList)) {
-            // this might be called from an intrinsic, like map, trying to create an empty array
-            // passing `0` as the only parameter
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return new Array(coList) as any;
-        }
-        super(
-            ...coList
-                .asArray()
-                .map(
-                    (item) =>
-                        queryContext.queryIfCoID(item, [coList.id]) as ValueOrSubQueried<
-                            L["_item"]
-                        >
-                )
-        );
-
-        Object.defineProperties(this, {
-            coList: { get() {return coList} },
-            id: { value: coList.id },
-            type: { value: "colist" },
-            edits: {
-                value: [...this.keys()].map((i) => {
-                    const edit = coList.editAt(i)!;
-                    return queryContext.defineSubqueryPropertiesIn({
-
-                        tx: edit.tx,
-                        at: new Date(edit.at),
-                    }, {
-                        by: {value: edit.by, enumerable: true},
-                        value: {value: edit.value, enumerable: true},
-                    }, [coList.id]);
-                }),
-            },
-            deletions: {
-                value: coList.deletionEdits().map((deletion) => queryContext.defineSubqueryPropertiesIn({
-
-                    tx: deletion.tx,
-                    at: new Date(deletion.at),
-                }, {
-                    by: {value: deletion.by, enumerable: true},
-                }, [coList.id])),
-            },
-        });
-    }
-
-    get meta(): L["meta"] {
-        return this.coList.meta;
-    }
-
-    get group(): Group {
-        return this.coList.group;
-    }
-
-    get core(): CoValueCore {
-        return this.coList.core;
-    }
-
-    append(
-        item: L["_item"],
-        after?: number,
-        privacy?: "private" | "trusting"
-    ): L {
-        return this.coList.append(item, after, privacy);
-    }
-
-    prepend(
-        item: L["_item"],
-        before?: number,
-        privacy?: "private" | "trusting"
-    ): L {
-        return this.coList.prepend(item, before, privacy);
-    }
-
-    delete(at: number, privacy?: "private" | "trusting"): L {
-        return this.coList.delete(at, privacy);
-    }
-
-    mutate(
-        mutator: (mutable: MutableCoList<L["_item"], L["meta"]>) => void
-    ): L {
-        return this.coList.mutate(mutator);
-    }
-
-    edits!: {
-        by?: QueriedAccount;
-        tx: TransactionID;
-        at: Date;
-        value: L["_item"] extends CoValue
-            ? CoID<L["_item"]>
-            : Exclude<L["_item"], CoValue>;
-    }[];
-
-    deletions!: {
-        by?: QueriedAccount;
-        tx: TransactionID;
-        at: Date;
-    }[];
-
-    /** @internal */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static isArray(arg: any): arg is any[] {
-        return Array.isArray(arg);
-    }
-
-    /** @internal */
-    static from<T>(arrayLike: ArrayLike<T>): T[];
-    /** @internal */
-    static from<T, U>(
-        arrayLike: ArrayLike<T>,
-        mapfn: (v: T, k: number) => U,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        thisArg?: any
-    ): U[];
-    /** @internal */
-    static from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
-    /** @internal */
-    static from<T, U>(
-        iterable: Iterable<T> | ArrayLike<T>,
-        mapfn: (v: T, k: number) => U,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        thisArg?: any
-    ): U[];
-    /** @internal */
-    static from<T, U>(
-        _iterable: unknown,
-        _mapfn?: unknown,
-        _thisArg?: unknown
-    ): T[] | U[] | T[] | U[] {
-        throw new Error("Array method 'from' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    static of<T>(..._items: T[]): T[] {
-        throw new Error("Array method 'of' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    pop(): ValueOrSubQueried<L["_item"]> | undefined {
-        throw new Error("Array method 'pop' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    push(..._items: ValueOrSubQueried<L["_item"]>[]): number {
-        throw new Error("Array method 'push' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    concat(
-        ..._items: ConcatArray<ValueOrSubQueried<L["_item"]>>[]
-    ): ValueOrSubQueried<L["_item"]>[];
-    /** @internal */
-    concat(
-        ..._items: (
-            | ValueOrSubQueried<L["_item"]>
-            | ConcatArray<ValueOrSubQueried<L["_item"]>>
-        )[]
-    ): ValueOrSubQueried<L["_item"]>[];
-    /** @internal */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    concat(..._items: any[]): ValueOrSubQueried<L["_item"]>[] {
-        throw new Error("Array method 'concat' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    reverse(): ValueOrSubQueried<L["_item"]>[] {
-        throw new Error(
-            "Array method 'reverse' not supported on QueriedCoList"
-        );
-    }
-
-    /** @internal */
-    shift(): ValueOrSubQueried<L["_item"]> | undefined {
-        throw new Error("Array method 'shift' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    sort(
-        _compareFn?:
-            | ((
-                  a: ValueOrSubQueried<L["_item"]>,
-                  b: ValueOrSubQueried<L["_item"]>
-              ) => number)
-            | undefined
-    ): this {
-        throw new Error("Array method 'sort' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    splice(
-        _start: number,
-        _deleteCount?: number | undefined
-    ): ValueOrSubQueried<L["_item"]>[] {
-        throw new Error("Array method 'splice' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    unshift(..._items: ValueOrSubQueried<L["_item"]>[]): number {
-        throw new Error(
-            "Array method 'unshift' not supported on QueriedCoList"
-        );
-    }
-
-    /** @internal */
-    fill(
-        _value: ValueOrSubQueried<L["_item"]>,
-        _start?: number | undefined,
-        _end?: number | undefined
-    ): this {
-        throw new Error("Array method 'fill' not supported on QueriedCoList");
-    }
-
-    /** @internal */
-    copyWithin(
-        _target: number,
-        _start: number,
-        _end?: number | undefined
-    ): this {
-        throw new Error(
-            "Array method 'copyWithin' not supported on QueriedCoList"
-        );
-    }
-}

package/src/queriedCoValues/queriedCoMap.ts

@@ -1,168 +0,0 @@
-import { CoMap, MutableCoMap } from "../coValues/coMap.js";
-import { CoValueCore } from "../coValueCore.js";
-import { Group } from "../coValues/group.js";
-import { CoID } from "../coValue.js";
-import { TransactionID } from "../ids.js";
-import { ValueOrSubQueried, QueryContext, QueryExtension } from "../queries.js";
-import { QueriedAccount } from "./queriedAccount.js";
-
-export type QueriedCoMap<M extends CoMap> = {
-    [K in keyof M["_shape"] & string]: ValueOrSubQueried<M["_shape"][K]>;
-} & QueriedCoMapBase<M>;
-
-export type QueriedCoMapEdit<M extends CoMap, K extends keyof M["_shape"]> = {
-    by?: QueriedAccount;
-    tx: TransactionID;
-    at: Date;
-    value: M["_shape"][K];
-};
-
-export class QueriedCoMapBase<M extends CoMap> {
-    coMap!: M;
-    id!: CoID<M>;
-    type!: "comap";
-
-    /** @internal */
-    static newWithKVPairs<M extends CoMap>(
-        coMap: M,
-        queryContext: QueryContext
-    ): QueriedCoMap<M> {
-        const kv = {} as {
-            [K in keyof M["_shape"] & string]: ValueOrSubQueried<
-                M["_shape"][K]
-            >;
-        };
-        for (const key of coMap.keys()) {
-            const value = coMap.get(key);
-
-            if (value === undefined) continue;
-
-            queryContext.defineSubqueryPropertiesIn(
-                kv,
-                {
-                    [key]: { value, enumerable: true },
-                },
-                [coMap.id]
-            );
-        }
-
-        return Object.assign(new QueriedCoMapBase(coMap, queryContext), kv);
-    }
-
-    /** @internal */
-    constructor(coMap: M, queryContext: QueryContext) {
-        Object.defineProperties(this, {
-            coMap: {
-                get() {
-                    return coMap;
-                },
-                enumerable: false,
-            },
-            id: { value: coMap.id, enumerable: false },
-            type: { value: "comap", enumerable: false },
-            edits: {
-                value: Object.fromEntries(
-                    coMap.keys().flatMap((key) => {
-                        const edits = [...coMap.editsAt(key)].map((edit) =>
-                            queryContext.defineSubqueryPropertiesIn(
-                                {
-                                    tx: edit.tx,
-                                    at: new Date(edit.at),
-                                },
-                                {
-                                    by: { value: edit.by, enumerable: true },
-                                    value: {
-                                        value: edit.value,
-                                        enumerable: true,
-                                    },
-                                },
-                                [coMap.id]
-                            )
-                        );
-                        const lastEdit = edits[edits.length - 1];
-                        if (!lastEdit) return [];
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const editsAtKey = {
-                            by: lastEdit.by,
-                            tx: lastEdit.tx,
-                            at: lastEdit.at,
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            value: lastEdit.value as any,
-                            all: edits,
-                        };
-
-                        return [[key, editsAtKey]];
-                    })
-                ),
-                enumerable: false,
-            },
-            as: {
-                value: <O>(extension: QueryExtension<M, O>) => {
-                    return queryContext.getOrCreateExtension(
-                        coMap.id,
-                        extension
-                    );
-                },
-                enumerable: false,
-            },
-        });
-    }
-
-    edits!: {
-        [K in keyof M["_shape"] & string]:
-            | (QueriedCoMapEdit<M, K> & {
-                  all: QueriedCoMapEdit<M, K>[];
-              })
-            | undefined;
-    };
-
-    get meta(): M["meta"] {
-        return this.coMap.meta;
-    }
-
-    get group(): Group {
-        return this.coMap.group;
-    }
-
-    get core(): CoValueCore {
-        return this.coMap.core;
-    }
-
-    set<K extends keyof M["_shape"] & string>(
-        key: K,
-        value: M["_shape"][K],
-        privacy?: "private" | "trusting"
-    ): M;
-    set(
-        kv: {
-            [K in keyof M["_shape"] & string]?: M["_shape"][K];
-        },
-        privacy?: "private" | "trusting"
-    ): M;
-    set<K extends keyof M["_shape"] & string>(
-        ...args:
-            | [
-                  {
-                      [K in keyof M["_shape"] & string]?: M["_shape"][K];
-                  },
-                  ("private" | "trusting")?
-              ]
-            | [K, M["_shape"][K], ("private" | "trusting")?]
-    ): M {
-        // eslint-disable-next-line @typescript-eslint/ban-types
-        return (this.coMap.set as Function)(...args);
-    }
-    delete(
-        key: keyof M["_shape"] & string,
-        privacy?: "private" | "trusting"
-    ): M {
-        return this.coMap.delete(key, privacy);
-    }
-    mutate(
-        mutator: (mutable: MutableCoMap<M["_shape"], M["meta"]>) => void
-    ): M {
-        return this.coMap.mutate(mutator);
-    }
-
-    as!: <O>(extension: QueryExtension<M, O>) => O | undefined;
-}

package/src/queriedCoValues/queriedCoStream.ts

@@ -1,151 +0,0 @@
-import { JsonValue } from "../jsonValue.js";
-import { CoStream, MutableCoStream } from "../coValues/coStream.js";
-import { CoValueCore } from "../coValueCore.js";
-import { Group } from "../coValues/group.js";
-import { AccountID, isAccountID } from "../coValues/account.js";
-import { CoID, CoValue } from "../coValue.js";
-import { SessionID, TransactionID } from "../ids.js";
-import { ValueOrSubQueried, QueryContext } from "../queries.js";
-import { QueriedAccount } from "./queriedAccount.js";
-
-export type QueriedCoStreamEntry<Item extends JsonValue | CoValue> = {
-    last?: ValueOrSubQueried<Item>;
-    by?: QueriedAccount;
-    tx?: TransactionID;
-    at?: Date;
-    all: {
-        value: ValueOrSubQueried<Item>;
-        by?: QueriedAccount;
-        tx: TransactionID;
-        at: Date;
-    }[];
-};
-
-export class QueriedCoStream<S extends CoStream> {
-    coStream!: S;
-    id: CoID<S>;
-    type = "costream" as const;
-
-    /** @internal */
-    constructor(coStream: S, queryContext: QueryContext) {
-        Object.defineProperty(this, "coStream", {
-            get() {
-                return coStream;
-            },
-        });
-        this.id = coStream.id;
-
-        this.perSession = coStream.sessions().map((sessionID) => {
-            const items = [...coStream.itemsIn(sessionID)].map((item) =>
-                queryContext.defineSubqueryPropertiesIn(
-                    {
-                        tx: item.tx,
-                        at: new Date(item.at),
-                    },
-                    {
-                        by: {
-                            value: isAccountID(item.by)
-                                ? item.by
-                                : (undefined as never),
-                            enumerable: true,
-                        },
-                        value: {
-                            value: item.value as S["_item"],
-                            enumerable: true,
-                        },
-                    },
-                    [coStream.id]
-                )
-            );
-
-            const lastItem = items[items.length - 1];
-
-            return [
-                sessionID,
-                {
-                    get last() {
-                        return lastItem?.value;
-                    },
-                    get by() {
-                        return lastItem?.by;
-                    },
-                    tx: lastItem?.tx,
-                    at: lastItem?.at,
-                    all: items,
-                } satisfies QueriedCoStreamEntry<S["_item"]>,
-            ];
-        });
-
-        this.perAccount = [...coStream.accounts()].map((accountID) => {
-            const items = [...coStream.itemsBy(accountID)].map((item) =>
-                queryContext.defineSubqueryPropertiesIn(
-                    {
-                        tx: item.tx,
-                        at: new Date(item.at),
-                    },
-                    {
-                        by: {
-                            value: isAccountID(item.by)
-                                ? item.by
-                                : (undefined as never),
-                            enumerable: true,
-                        },
-                        value: {
-                            value: item.value as S["_item"],
-                            enumerable: true,
-                        },
-                    },
-                    [coStream.id]
-                )
-            );
-
-            const lastItem = items[items.length - 1];
-
-            const entry = {
-                get last() {
-                    return lastItem?.value;
-                },
-                get by() {
-                    return lastItem?.by;
-                },
-                tx: lastItem?.tx,
-                at: lastItem?.at,
-                all: items,
-            } satisfies QueriedCoStreamEntry<S["_item"]>;
-
-            if (accountID === queryContext.node.account.id) {
-                this.me = entry;
-            }
-
-            return [
-                accountID,
-                entry
-            ];
-        });
-    }
-
-    get meta(): S["meta"] {
-        return this.coStream.meta;
-    }
-
-    get group(): Group {
-        return this.coStream.group;
-    }
-
-    get core(): CoValueCore {
-        return this.coStream.core;
-    }
-
-    me?: QueriedCoStreamEntry<S["_item"]>;
-    perAccount: [account: AccountID, items: QueriedCoStreamEntry<S["_item"]>][];
-    perSession: [session: SessionID, items: QueriedCoStreamEntry<S["_item"]>][];
-
-    push(item: S["_item"], privacy?: "private" | "trusting"): S {
-        return this.coStream.push(item, privacy);
-    }
-    mutate(
-        mutator: (mutable: MutableCoStream<S["_item"], S["meta"]>) => void
-    ): S {
-        return this.coStream.mutate(mutator);
-    }
-}

package/src/queriedCoValues/queriedGroup.ts

@@ -1,90 +0,0 @@
-import { Everyone, Group, InviteSecret } from "../coValues/group.js";
-import { CoID } from "../coValue.js";
-import { QueryContext, ValueOrSubQueried } from "../queries.js";
-import { CoValueCore } from "../coValueCore.js";
-import { Role } from "../permissions.js";
-import { AccountID } from "../coValues/account.js";
-import { CoMap } from "../coValues/coMap.js";
-import { CoList } from "../coValues/coList.js";
-import { CoStream } from "../coValues/coStream.js";
-import { BinaryCoStream } from "../coValues/coStream.js";
-
-export class QueriedGroup<G extends Group = Group> {
-    group!: G;
-    id!: CoID<G>;
-    type = "group" as const;
-    profile?: ValueOrSubQueried<G["_shape"]["profile"]>;
-    root?: ValueOrSubQueried<G["_shape"]["root"]>;
-
-    constructor(group: G, queryContext: QueryContext) {
-        const profileID = group.get("profile");
-        const rootID = group.get("root");
-        queryContext.defineSubqueryPropertiesIn(Object.defineProperties(this, {
-            group: {
-                get() {
-                    return group;
-                },
-                enumerable: false,
-            },
-            id: { value: group.id, enumerable: false },
-            type: { value: "group", enumerable: false },
-        }), {
-            profile: {
-                value: profileID,
-                enumerable: false,
-            },
-            root: {
-                value: rootID,
-                enumerable: false,
-            },
-        }, [group.id]);
-    }
-
-    get meta(): G["meta"] {
-        return this.group.meta;
-    }
-
-    get core(): CoValueCore {
-        return this.group.core;
-    }
-
-    addMember(accountID: AccountID | Everyone, role: Role): G {
-        return this.group.addMember(accountID, role);
-    }
-
-    removeMember(accountID: AccountID): G {
-        return this.group.removeMember(accountID);
-    }
-
-    createInvite(role: "reader" | "writer" | "admin"): InviteSecret {
-        return this.group.createInvite(role);
-    }
-
-    createMap<M extends CoMap>(
-        init?: {
-            [K in keyof M["_shape"]]: M["_shape"][K];
-        },
-        meta?: M["meta"],
-        initPrivacy: "trusting" | "private" = "private"
-    ): M {
-        return this.group.createMap(init, meta, initPrivacy);
-    }
-
-    createList<L extends CoList>(
-        init?: L["_item"][],
-        meta?: L["meta"],
-        initPrivacy: "trusting" | "private" = "private"
-    ): L {
-        return this.group.createList(init, meta, initPrivacy);
-    }
-
-    createStream<C extends CoStream>(meta?: C["meta"]): C {
-        return this.group.createStream(meta);
-    }
-
-    createBinaryStream<C extends BinaryCoStream>(
-        meta: C["meta"] = { type: "binary" }
-    ): C {
-        return this.group.createBinaryStream(meta);
-    }
-}