localdb-ces6q 0.0.2

package/src/LocalDBDocument.d.ts

@@ -0,0 +1,18 @@
+import { PubSub } from 'util-3gcvv/class/PubSub.js';
+import type { KeyOf } from 'util-3gcvv/types/types.js';
+export declare class LocalDBDocument<Data = any> extends PubSub<[
+    Data,
+    Data,
+    Array<KeyOf<Data>>
+]> {
+    private _data;
+    constructor(data: Data);
+    toJSON(): Data;
+    equals(other: LocalDBDocument<Data>): boolean;
+    destroy(): void;
+    get id(): string;
+    get data(): Data;
+    set data(next: Data);
+    set(next: Data): void;
+    update(update: Partial<Data>): void;
+}

package/src/LocalDBDocument.js

@@ -0,0 +1,55 @@
+import { PubSub } from 'util-3gcvv/class/PubSub.js';
+import { deepEqual } from 'util-3gcvv/deepEqual.js';
+import { objectKeys } from 'util-3gcvv/object.js';
+export class LocalDBDocument extends PubSub {
+    constructor(data) {
+        super();
+        this._data = data;
+    }
+    toJSON() {
+        return this._data;
+    }
+    equals(other) {
+        return deepEqual(this._data, other._data);
+    }
+    destroy() {
+        super.destroy();
+        this._data = null;
+    }
+    get id() {
+        return this._data.id;
+    }
+    get data() {
+        return this._data;
+    }
+    set data(next) {
+        this.set(next);
+    }
+    set(next) {
+        return this.update(next);
+    }
+    update(update) {
+        const prev = this._data;
+        const keys = objectKeys(update);
+        const changed = {};
+        const changedKeys = [];
+        const next = { ...prev };
+        for (let i = 0, il = keys.length; i < il; i += 1) {
+            const key = keys[i];
+            if (!deepEqual(update[key], prev[key])) {
+                changed[key] = update[key];
+                if (update[key] === undefined) {
+                    delete next[key];
+                }
+                else {
+                    next[key] = update[key];
+                }
+                changedKeys.push(key);
+            }
+        }
+        if (changedKeys.length) {
+            this._data = next;
+            this.emit(next, prev, changedKeys);
+        }
+    }
+}

package/src/LocalDBState.d.ts

@@ -0,0 +1,14 @@
+import { SmartState } from 'util-3gcvv/class/SmartState.js';
+import type { IDBOperationHistoryItem } from './types.js';
+export interface ILocalDBStateProps {
+    history: IDBOperationHistoryItem[][];
+    historyIndex: number;
+    canRedo: boolean;
+    canUndo: boolean;
+    redoItem: IDBOperationHistoryItem[] | undefined;
+    undoItem: IDBOperationHistoryItem[] | undefined;
+}
+type ComputedKeys = 'canUndo' | 'canRedo' | 'redoItem' | 'undoItem';
+export declare const LocalDBState: import("util-3gcvv/class/SmartState.js").SmartStateConstructor<ILocalDBStateProps, ComputedKeys, {}, import("util-3gcvv/class/SmartState.js").IEmptyInterface>;
+export type LocalDBState = SmartState<ILocalDBStateProps, ComputedKeys, {}>;
+export {};

package/src/LocalDBState.js

@@ -0,0 +1,46 @@
+import { defineSmartState } from 'util-3gcvv/class/SmartState.js';
+export const LocalDBState = defineSmartState({
+    statics: {
+        name: 'LocalDBState',
+        fromJSON: (json) => new LocalDBState(json.state, json.config),
+    },
+    properties: {
+        history: { type: 'array', item: 'object' },
+        historyIndex: { type: 'number' },
+    },
+    computed: {
+        // []
+        // [a, b, c, d]
+        canRedo: {
+            type: 'boolean',
+            deps: ['redoItem'],
+            get({ redoItem }) {
+                return redoItem != null;
+            },
+        },
+        canUndo: {
+            type: 'boolean',
+            deps: ['undoItem'],
+            get({ undoItem }) {
+                return undoItem != null;
+            },
+        },
+        redoItem: {
+            type: 'array',
+            item: 'object',
+            deps: ['history', 'historyIndex'],
+            get({ history, historyIndex }) {
+                return history[historyIndex];
+            },
+        },
+        undoItem: {
+            type: 'array',
+            item: 'object',
+            deps: ['history', 'historyIndex'],
+            get({ history, historyIndex }) {
+                return history[historyIndex - 1];
+            },
+        },
+    },
+    drafts: [],
+});

package/src/comparators.d.ts

@@ -0,0 +1,15 @@
+export declare const compareNil: (a: any, b: any) => number | null;
+export declare const defaultComparators: {
+    string: {
+        asc: (a: string | null | undefined, b: string | null | undefined) => number;
+        desc: (a: string | null | undefined, b: string | null | undefined) => number;
+    };
+    number: {
+        asc: (a: number | null | undefined, b: number | null | undefined) => number;
+        desc: (a: number | null | undefined, b: number | null | undefined) => number;
+    };
+    boolean: {
+        asc: (a: boolean | null | undefined, b: boolean | null | undefined) => number;
+        desc: (a: boolean | null | undefined, b: boolean | null | undefined) => number;
+    };
+};

package/src/comparators.js

@@ -0,0 +1,105 @@
+export const compareNil = (a, b) => {
+    if (a === b)
+        return 0;
+    if (a === undefined)
+        return 1;
+    if (b === undefined)
+        return -1;
+    if (a === null)
+        return 1;
+    if (b === null)
+        return -1;
+    return null;
+};
+export const defaultComparators = {
+    string: {
+        // a -> z
+        asc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return a.localeCompare(b);
+        },
+        // z -> a
+        desc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return b.localeCompare(a);
+        },
+    },
+    number: {
+        // 0 -> 9
+        asc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return a - b;
+        },
+        // 9 -> 0
+        desc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return b - a;
+        },
+    },
+    boolean: {
+        // false -> true
+        asc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return (a ? 1 : 0) - (b ? 1 : 0);
+        },
+        // true -> false
+        desc: (a, b) => {
+            if (a === b)
+                return 0;
+            if (a === undefined)
+                return 1;
+            if (b === undefined)
+                return -1;
+            if (a === null)
+                return 1;
+            if (b === null)
+                return -1;
+            return (b ? 1 : 0) - (a ? 1 : 0);
+        },
+    },
+};

package/src/hooks.d.ts

@@ -0,0 +1,5 @@
+import type { LocalDB } from './LocalDB.js';
+import type { IDocument } from './types.js';
+import type { KeyOf } from 'util-3gcvv/types/types.js';
+export declare const useLocalDbDoc: <T extends Record<string, IDocument>, K extends KeyOf<T>>(db: LocalDB<T>, col: K, id: string, deps?: any[]) => T[K] | undefined;
+export declare const useLocalDbDocs: <T extends Record<string, IDocument>, K extends KeyOf<T>>(db: LocalDB<T>, col: K, ids: string[] | null | undefined, deps?: any[]) => (T[K] | undefined)[];

package/src/hooks.js

@@ -0,0 +1,34 @@
+import { useEffect, useRef, useState } from 'react';
+import { arraysEqual } from 'util-3gcvv/array.js';
+export const useLocalDbDoc = (db, col, id, deps = [db, col, id]) => {
+    const [doc, setDoc] = useState(() => db.doc(col, id));
+    useEffect(() => {
+        setDoc(db.doc(col, id));
+        return db.subToDoc(col, id, setDoc);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+    return doc;
+};
+export const useLocalDbDocs = (db, col, ids, deps = [db, col, ids]) => {
+    const [docs, setDocs] = useState(() => ids?.length ? db.docs(col, ids) : []);
+    const docsRef = useRef(docs);
+    useEffect(() => {
+        const newDocs = ids?.length ? db.docs(col, ids) : [];
+        if (!arraysEqual(docsRef.current, newDocs)) {
+            docsRef.current = newDocs;
+            setDocs(newDocs);
+        }
+        if (!ids?.length)
+            return;
+        return db.subToCol(col, (next, prev, change) => {
+            for (let i = 0, il = ids.length; i < il; i += 1) {
+                if (ids[i] in change) {
+                    docsRef.current = ids.map((id) => next[id]);
+                    return setDocs(docsRef.current);
+                }
+            }
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+    return docs;
+};

package/src/types.d.ts

@@ -0,0 +1,100 @@
+import type { LocalDB } from './LocalDB.js';
+import type { KeyOf } from 'util-3gcvv/types/types.js';
+export interface IDocument {
+    id: string;
+}
+export type Collections<CollectionTypes extends Record<string, IDocument>> = {
+    [ColName in KeyOf<CollectionTypes>]: {
+        [id in string]: CollectionTypes[ColName];
+    };
+};
+export type CollectionsChange<CollectionTypes extends Record<string, IDocument>> = {
+    [ColName in KeyOf<CollectionTypes>]?: {
+        [id in string]: Partial<CollectionTypes[ColName]> | null;
+    };
+};
+export type CollectionsChangeMap<CollectionTypes extends Record<string, IDocument>> = {
+    [ColName in KeyOf<CollectionTypes>]?: {
+        [Field in KeyOf<CollectionTypes[ColName]>]: true;
+    };
+};
+export type Collection<CollectionTypes extends Record<string, IDocument>, ColName extends KeyOf<CollectionTypes>> = Record<string, CollectionTypes[ColName]>;
+export type ICollectionFieldsConfig<Doc extends IDocument> = {
+    [P in KeyOf<Doc>]: {
+        type: 'boolean' | 'number' | 'string' | 'array' | 'object' | 'boolean[]' | 'number[]' | 'string[]' | 'array[]' | 'object[]';
+        nullable?: boolean;
+        normalize?(next: Doc[P], doc: Doc): Doc[P];
+        equals?(a: Doc[P], b: Doc[P]): boolean;
+        compare?(a: Doc[P] | null | undefined, b: Doc[P] | null | undefined): number;
+        index?: 'asc' | 'desc';
+    };
+};
+export interface ICollectionConfig<CollectionTypes extends Record<string, IDocument>, Doc extends IDocument> {
+    localStorageKey?: string;
+    localStorageSetWait?: number;
+    remoteStorageKey?: string;
+    remoteStorageSetWait?: number;
+    indexes?: Array<KeyOf<Doc> | Array<KeyOf<Doc>>>;
+    idFields?: Array<KeyOf<Doc>>;
+    fields: ICollectionFieldsConfig<Doc>;
+    computes?: Array<{
+        deps: Array<KeyOf<Doc>>;
+        mutates: Array<KeyOf<Doc>>;
+        compute: (next: Doc, prev: Doc) => Partial<Doc> | null;
+    }>;
+    foreignComputes?: Array<{
+        mutates: Array<KeyOf<CollectionTypes>>;
+        compute: (db: LocalDB<CollectionTypes>, updates: Array<{
+            next: Doc | null;
+            prev: Doc | null;
+        }>) => void;
+    }>;
+}
+export type ICollectionsConfig<CollectionTypes extends Record<string, IDocument>> = {
+    [ColName in KeyOf<CollectionTypes>]: ICollectionConfig<CollectionTypes, CollectionTypes[ColName]>;
+};
+export type ICollectionsFields<CollectionTypes extends Record<string, IDocument>> = {
+    [ColName in KeyOf<CollectionTypes>]: Array<KeyOf<CollectionTypes[ColName]>>;
+};
+export type FieldListener<CollectionTypes extends Record<string, IDocument>, ColName extends KeyOf<CollectionTypes>, FieldName extends KeyOf<CollectionTypes[ColName]>> = (nextField: CollectionTypes[ColName][FieldName], prevField: CollectionTypes[ColName][FieldName], nextDoc: CollectionTypes[ColName], prevDoc: CollectionTypes[ColName], context: IDBTxContext) => void;
+export type DocListener<CollectionTypes extends Record<string, IDocument>, ColName extends KeyOf<CollectionTypes>> = (nextDoc: CollectionTypes[ColName], prevDoc: CollectionTypes[ColName], change: Partial<CollectionTypes[ColName]> | null, context: IDBTxContext) => void;
+export type ColListener<CollectionTypes extends Record<string, IDocument>, ColName extends KeyOf<CollectionTypes>> = (nextCol: Record<string, CollectionTypes[ColName]>, prevCol: Record<string, CollectionTypes[ColName]>, change: CollectionsChange<CollectionTypes>[ColName], changedFields: CollectionsChangeMap<CollectionTypes>[ColName], context: IDBTxContext) => void;
+export type DBListener<CollectionTypes extends Record<string, IDocument>> = (nextDb: Collections<CollectionTypes>, prevDb: Collections<CollectionTypes>, change: CollectionsChange<CollectionTypes>, changedFields: CollectionsChangeMap<CollectionTypes>, context: IDBTxContext) => void;
+export interface IDBOperations<CollectionTypes extends Record<string, IDocument> = any> {
+    setDoc<ColName extends KeyOf<CollectionTypes>>(colName: ColName, doc: CollectionTypes[ColName]): void;
+    setDocs<ColName extends KeyOf<CollectionTypes>>(colName: ColName, docs: Array<CollectionTypes[ColName]>): void;
+    updateDoc<ColName extends KeyOf<CollectionTypes>>(colName: ColName, id: string, updater: Partial<CollectionTypes[ColName]> | ((prev: CollectionTypes[ColName]) => Partial<CollectionTypes[ColName]> | null | undefined)): void;
+    updateDocs<ColName extends KeyOf<CollectionTypes>>(colName: ColName, updater: Record<string, Partial<CollectionTypes[ColName]>> | ((prev: Collections<CollectionTypes>[ColName]) => Record<string, Partial<CollectionTypes[ColName]> | null | undefined> | null | undefined)): void;
+    deleteDoc<ColName extends KeyOf<CollectionTypes>>(colName: ColName, id: string): void;
+    deleteDocs<ColName extends KeyOf<CollectionTypes>>(colName: ColName, ids: string[]): void;
+}
+export type DBOpType = KeyOf<IDBOperations>;
+export type IDBOperation = {
+    [Op in KeyOf<IDBOperations>]: {
+        op: Op;
+        args: Parameters<IDBOperations[Op]>;
+    };
+}[KeyOf<IDBOperations>];
+export interface IDBOperationHistoryItem {
+    undo: IDBOperation;
+    redo: IDBOperation;
+}
+export interface IDBTxContext {
+    [key: string]: any;
+}
+export interface IDBTxOptions {
+    undoable?: boolean;
+    noEvent?: boolean;
+    ignoreNotFound?: boolean;
+    idempotent?: boolean;
+    context?: IDBTxContext;
+}
+export interface IDBQuery<CollectionTypes extends Record<string, IDocument>, ColName extends KeyOf<CollectionTypes>> {
+    collection: ColName;
+    orderBy: string;
+    limit: number;
+    endAfter?: any;
+    endAt?: any;
+    startAfter?: any;
+    startAt?: any;
+}

package/src/types.js

@@ -0,0 +1 @@
+export {};

package/test/LocalDB.test.d.ts

@@ -0,0 +1 @@
+export {};