react-rock 3.2.8 → 3.2.9

package/Store.d.ts

@@ -1,32 +1,31 @@
-import { RowSchema, MetaSchema, MakeRowType, WhereType } from './types.js';
+import { RowSchema, MetaSchema, MakeRowType, CreateManyArgs, CreateArgs, UpdateArgs, DeleteArgs, FindArgs, MoveArgs } from './types.js';
 import { Infer } from 'xanv';
 
-declare class Store<RS extends RowSchema, MS extends MetaSchema | undefined = undefined> {
-    private _rows;
-    private _meta;
-    private _hooks;
-    private _timer;
-    private _row_schema;
-    private _meta_schema?;
-    private _last_id;
-    constructor(rowSchema: RS, metaSchema?: MS);
-    private observe;
-    private dispatch;
-    rows(observe?: boolean): MakeRowType<RS>[];
-    metas(observe?: boolean): Map<keyof Infer<MS>, Infer<MS>[keyof Infer<MS>]>;
-    create(row: Partial<MakeRowType<RS>>, observe?: boolean): MakeRowType<RS>;
-    create(row: Partial<MakeRowType<RS>>[], observe?: boolean): MakeRowType<RS>[];
-    update(row: Partial<MakeRowType<RS>>, where?: WhereType<RS> | null, observe?: boolean): MakeRowType<RS>[] | null;
-    delete(where?: WhereType<RS> | null, observe?: boolean): number;
-    find(where?: WhereType<RS> | null, observe?: boolean): MakeRowType<RS>[];
-    findOne(where: WhereType<RS>, observe?: boolean): MakeRowType<RS> | null;
-    findById(rid: string, observe?: boolean): MakeRowType<RS> | null;
-    getIndex(where: WhereType<RS>, observe?: boolean): number;
-    move(fromIndex: number, toIndex: number, observe?: boolean): boolean;
-    setMeta<T extends keyof Infer<MS>>(key: T, value: Infer<MS>[T], observe?: boolean): void;
-    getMeta<T extends keyof Infer<MS>>(key: T, observe?: boolean): Infer<MS>[T] | undefined;
-    deleteMeta<T extends keyof Infer<MS>>(key: T, observe?: boolean): void;
-    clearMeta(observe?: boolean): void;
+declare class Store<RS extends RowSchema, MS extends MetaSchema | undefined = undefined> {
+    private _rows;
+    private _meta;
+    private _hooks;
+    private _timer;
+    private _row_schema;
+    private _meta_schema?;
+    private _last_id;
+    constructor(rowSchema: RS, metaSchema?: MS);
+    private observe;
+    dispatch(observeIdOrCallbabck?: string | ((cb: Function, key: string) => void)): void;
+    rows(observe?: boolean): MakeRowType<RS>[];
+    metas(observe?: boolean): Map<keyof Infer<MS>, Infer<MS>[keyof Infer<MS>]>;
+    createMany(args: CreateManyArgs<RS>): (MakeRowType<RS> | MakeRowType<RS>[])[];
+    create(args: CreateArgs<RS>): MakeRowType<RS> | MakeRowType<RS>[];
+    update(args: UpdateArgs<RS>): MakeRowType<RS>[] | null;
+    delete(args: DeleteArgs<RS>): number;
+    find(args: FindArgs<RS>): MakeRowType<RS>[];
+    findOne(args: FindArgs<RS>): MakeRowType<RS> | null;
+    getIndex(args: FindArgs<RS>): number;
+    move(args: MoveArgs<RS>): boolean;
+    setMeta<T extends keyof Infer<MS>>(key: T, value: Infer<MS>[T], observe?: boolean): void;
+    getMeta<T extends keyof Infer<MS>>(key: T, observe?: boolean): Infer<MS>[T] | undefined;
+    deleteMeta<T extends keyof Infer<MS>>(key: T, observe?: boolean): void;
+    clearMeta(observe?: boolean): void;
 }
 
 export { Store as default };

package/Store.js

@@ -2,257 +2,293 @@
 import { useId, useState, useEffect } from 'react';
 import { xv } from 'xanv';
 
-const uid = useId;
-const ustate = useState;
-const ueffect = useEffect;
-class Store {
-    constructor(rowSchema, metaSchema) {
-        this._rows = [];
-        this._meta = new Map();
-        this._hooks = new Map();
-        this._timer = null;
-        this._last_id = 0;
-        this.observe = () => {
-            try {
-                const hid = uid();
-                const [, dispatch] = ustate(0);
-                this._hooks.set(hid, () => dispatch(Math.random()));
-                ueffect(() => () => {
-                    this._hooks.delete(hid);
-                }, []);
-            }
-            catch (error) { }
-        };
-        this.dispatch = () => {
-            clearTimeout(this._timer);
-            this._timer = setTimeout(() => {
-                this._hooks.forEach((cb, key) => {
-                    try {
-                        cb();
-                    }
-                    catch (_err) {
-                        this._hooks.delete(key);
-                    }
-                });
-            }, 0);
-        };
-        this._row_schema = Object.assign(Object.assign({}, rowSchema), { rid: xv.number(), vid: xv.number().default(() => Math.round((Math.random() + Math.random()) * 9999999999)) });
-        this._meta_schema = metaSchema;
-    }
-    rows(observe = true) {
-        observe && this.observe();
-        return this._rows;
-    }
-    metas(observe = true) {
-        observe && this.observe();
-        return this._meta;
-    }
-    create(row, observe = true) {
-        if (Array.isArray(row)) {
-            const rows = [];
-            for (const r of row) {
-                rows.push(this.create(r, false));
-            }
-            observe && this.dispatch();
-            return rows;
-        }
-        // validate and create row
-        let r = {};
-        for (let key in this._row_schema) {
-            if (key === "rid" || key === "vid")
-                continue;
-            const schema = this._row_schema[key];
-            r[key] = schema.parse(row[key]);
-        }
-        this._last_id = this._last_id + 1;
-        const _row = Object.assign(Object.assign({}, r), { rid: this._last_id, vid: this._row_schema.vid.parse(undefined) });
-        this._rows.push(_row);
-        observe && this.dispatch();
-        return _row;
-    }
-    // update
-    update(row, where, observe = true) {
-        // validate row
-        let r = {};
-        for (let key in row) {
-            if (key === "rid" || key === 'vid')
-                continue;
-            const schema = this._row_schema[key];
-            r[key] = schema.parse(row[key]);
-        }
-        const rows = this.find(where);
-        if (rows.length > 0) {
-            for (let index = 0; index < rows.length; index++) {
-                const _row = rows[index];
-                const rid = _row.rid;
-                rows[index] = Object.assign(Object.assign(Object.assign({}, _row), r), { rid, vid: this._row_schema.vid.parse(undefined) });
-                const rowIndex = this._rows.findIndex(r => r.rid === rid);
-                this._rows[rowIndex] = rows[index];
-            }
-            observe && this.dispatch();
-        }
-        return this.find(where);
-    }
-    // delete
-    delete(where, observe = true) {
-        const rows = this.find(where, false);
-        let deletedCount = 0;
-        if (rows.length > 0) {
-            this._rows = this._rows.filter(r => !rows.find(dr => dr.rid === r.rid));
-            deletedCount = rows.length;
-            observe && this.dispatch();
-        }
-        return deletedCount;
-    }
-    // find
-    find(where, observe = true) {
-        observe && this.observe();
-        if (!where) {
-            return this._rows;
-        }
-        const rows = [];
-        for (const row of this._rows) {
-            const match = Object.keys(row).find(column => {
-                let _match = true;
-                const rvalue = row[column];
-                for (let wcol in where) {
-                    const wv = where[wcol];
-                    if (typeof wv === "object" && wv !== null) {
-                        if (wv.contain !== undefined) {
-                            if (typeof rvalue === "string" && typeof wv.contain === "string") {
-                                if (!rvalue.includes(wv.contain)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.startWith !== undefined) {
-                            if (typeof rvalue === "string" && typeof wv.startWith === "string") {
-                                if (!rvalue.startsWith(wv.startWith)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.endWith !== undefined) {
-                            if (typeof rvalue === "string" && typeof wv.endWith === "string") {
-                                if (!rvalue.endsWith(wv.endWith)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.equalWith !== undefined) {
-                            if (rvalue !== wv.equalWith) {
-                                _match = false;
-                            }
-                        }
-                        if (wv.notEqualWith !== undefined) {
-                            if (rvalue === wv.notEqualWith) {
-                                _match = false;
-                            }
-                        }
-                        if (wv.gt !== undefined) {
-                            if (typeof rvalue === "number") {
-                                if (!(rvalue > wv.gt)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.lt !== undefined) {
-                            if (typeof rvalue === "number") {
-                                if (!(rvalue < wv.lt)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.gte !== undefined) {
-                            if (typeof rvalue === "number") {
-                                if (!(rvalue >= wv.gte)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        if (wv.lte !== undefined) {
-                            if (typeof rvalue === "number") {
-                                if (!(rvalue <= wv.lte)) {
-                                    _match = false;
-                                }
-                            }
-                            else {
-                                _match = false;
-                            }
-                        }
-                        continue;
-                    }
-                    if (wv !== rvalue) {
-                        _match = false;
-                        break;
-                    }
-                }
-                return _match;
-            });
-            if (match) {
-                rows.push(row);
-            }
-        }
-        return rows;
-    }
-    findOne(where, observe = true) {
-        const rows = this.find(where, observe);
-        return rows.length > 0 ? rows[0] : null;
-    }
-    findById(rid, observe = true) {
-        return this.findOne({ rid }, observe);
-    }
-    getIndex(where, observe = true) {
-        observe && this.observe();
-        const row = this.findOne(where, false);
-        if (row) {
-            return this._rows.findIndex(r => r.rid === row.rid);
-        }
-        return -1;
-    }
-    move(fromIndex, toIndex, observe = true) {
-        if (fromIndex < 0 || toIndex < 0)
-            return false;
-        const [movedRow] = this._rows.splice(fromIndex, 1);
-        this._rows.splice(toIndex, 0, movedRow);
-        observe && this.dispatch();
-        return true;
-    }
-    // Meta Methods
-    setMeta(key, value, observe = true) {
-        this._meta.set(key, this._meta_schema ? this._meta_schema[key].parse(value) : value);
-        observe && this.dispatch();
-    }
-    getMeta(key, observe = true) {
-        observe && this.observe();
-        return this._meta.get(key);
-    }
-    deleteMeta(key, observe = true) {
-        this._meta.delete(key);
-        observe && this.dispatch();
-    }
-    clearMeta(observe = true) {
-        this._meta.clear();
-        observe && this.dispatch();
-    }
+const uid = useId;
+const ustate = useState;
+const ueffect = useEffect;
+class Store {
+    constructor(rowSchema, metaSchema) {
+        this._rows = [];
+        this._meta = new Map();
+        this._hooks = new Map();
+        this._timer = null;
+        this._last_id = 0;
+        this.observe = (observeId) => {
+            try {
+                const hid = uid();
+                const id = observeId || hid;
+                const [, dispatch] = ustate(0);
+                this._hooks.set(id, () => dispatch(Math.random()));
+                ueffect(() => () => {
+                    this._hooks.delete(id);
+                }, []);
+            }
+            catch (error) { }
+        };
+        this._row_schema = Object.assign(Object.assign({}, rowSchema), { rid: xv.number(), vid: xv.number().default(() => Math.round((Math.random() + Math.random()) * 9999999999)) });
+        this._meta_schema = metaSchema;
+    }
+    dispatch(observeIdOrCallbabck) {
+        clearTimeout(this._timer);
+        const isFn = typeof observeIdOrCallbabck === "function";
+        this._timer = setTimeout(() => {
+            this._hooks.forEach((cb, key) => {
+                try {
+                    if (isFn) {
+                        observeIdOrCallbabck(cb, key);
+                    }
+                    else {
+                        if (observeIdOrCallbabck) {
+                            if (key === observeIdOrCallbabck) {
+                                cb();
+                            }
+                        }
+                        else {
+                            cb();
+                        }
+                    }
+                }
+                catch (_err) {
+                    this._hooks.delete(key);
+                }
+            });
+        }, 0);
+    }
+    rows(observe = true) {
+        observe && this.observe();
+        return this._rows;
+    }
+    metas(observe = true) {
+        observe && this.observe();
+        return this._meta;
+    }
+    createMany(args) {
+        const { data, disablelObservation, observeId } = args;
+        const res = [];
+        for (let row of data) {
+            const created = this.create({
+                data: row,
+                disablelObservation: true
+            });
+            res.push(created);
+        }
+        if (!disablelObservation) {
+            this.dispatch(observeId);
+        }
+        return res;
+    }
+    // Row Methods
+    create(args) {
+        const { data, disablelObservation, observeId } = args;
+        // validate and create row
+        let r = {};
+        for (let key in this._row_schema) {
+            if (key === "rid" || key === "vid")
+                continue;
+            const schema = this._row_schema[key];
+            r[key] = schema.parse(data[key]);
+        }
+        this._last_id = this._last_id + 1;
+        const _row = Object.assign(Object.assign({}, r), { rid: this._last_id, vid: this._row_schema.vid.parse(undefined) });
+        this._rows.push(_row);
+        if (!disablelObservation) {
+            this.dispatch(observeId);
+        }
+        return _row;
+    }
+    // update
+    update(args) {
+        const { data, where, disablelObservation, observeId } = args;
+        // validate row
+        let r = {};
+        for (let key in data) {
+            if (key === "rid" || key === 'vid')
+                continue;
+            const schema = this._row_schema[key];
+            r[key] = schema.parse(data[key]);
+        }
+        const rows = this.find({ where });
+        if (rows.length > 0) {
+            for (let index = 0; index < rows.length; index++) {
+                const _row = rows[index];
+                const rid = _row.rid;
+                rows[index] = Object.assign(Object.assign(Object.assign({}, _row), r), { rid, vid: this._row_schema.vid.parse(undefined) });
+                const rowIndex = this._rows.findIndex(r => r.rid === rid);
+                this._rows[rowIndex] = rows[index];
+            }
+            if (!disablelObservation) {
+                this.dispatch(observeId);
+            }
+        }
+        return this.find({ where, disablelObservation: true });
+    }
+    // delete
+    delete(args) {
+        const { where, disablelObservation, observeId } = args;
+        const rows = this.find({
+            where,
+            disablelObservation: true
+        });
+        let deletedCount = 0;
+        if (rows.length > 0) {
+            this._rows = this._rows.filter(r => !rows.find(dr => dr.rid === r.rid));
+            deletedCount = rows.length;
+            if (!disablelObservation) {
+                this.dispatch(observeId);
+            }
+        }
+        return deletedCount;
+    }
+    // find
+    find(args) {
+        let { where, disablelObservation, observeId } = args;
+        if (!disablelObservation) {
+            this.observe(observeId);
+        }
+        if (!where) {
+            return this._rows;
+        }
+        const rows = [];
+        for (const row of this._rows) {
+            const match = Object.keys(row).find(column => {
+                let _match = true;
+                const rvalue = row[column];
+                for (let wcol in where) {
+                    const wv = where[wcol];
+                    if (typeof wv === "object" && wv !== null) {
+                        if (wv.contain !== undefined) {
+                            if (typeof rvalue === "string" && typeof wv.contain === "string") {
+                                if (!rvalue.includes(wv.contain)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.startWith !== undefined) {
+                            if (typeof rvalue === "string" && typeof wv.startWith === "string") {
+                                if (!rvalue.startsWith(wv.startWith)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.endWith !== undefined) {
+                            if (typeof rvalue === "string" && typeof wv.endWith === "string") {
+                                if (!rvalue.endsWith(wv.endWith)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.equalWith !== undefined) {
+                            if (rvalue !== wv.equalWith) {
+                                _match = false;
+                            }
+                        }
+                        if (wv.notEqualWith !== undefined) {
+                            if (rvalue === wv.notEqualWith) {
+                                _match = false;
+                            }
+                        }
+                        if (wv.gt !== undefined) {
+                            if (typeof rvalue === "number") {
+                                if (!(rvalue > wv.gt)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.lt !== undefined) {
+                            if (typeof rvalue === "number") {
+                                if (!(rvalue < wv.lt)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.gte !== undefined) {
+                            if (typeof rvalue === "number") {
+                                if (!(rvalue >= wv.gte)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        if (wv.lte !== undefined) {
+                            if (typeof rvalue === "number") {
+                                if (!(rvalue <= wv.lte)) {
+                                    _match = false;
+                                }
+                            }
+                            else {
+                                _match = false;
+                            }
+                        }
+                        continue;
+                    }
+                    if (wv !== rvalue) {
+                        _match = false;
+                        break;
+                    }
+                }
+                return _match;
+            });
+            if (match) {
+                rows.push(row);
+            }
+        }
+        return rows;
+    }
+    findOne(args) {
+        const rows = this.find(args);
+        return rows.length > 0 ? rows[0] : null;
+    }
+    getIndex(args) {
+        const row = this.findOne(args);
+        if (row) {
+            return this._rows.findIndex(r => r.rid === row.rid);
+        }
+        return -1;
+    }
+    move(args) {
+        const { fromIndex, toIndex, disablelObservation, observeId } = args;
+        if (fromIndex < 0 || toIndex < 0)
+            return false;
+        const [movedRow] = this._rows.splice(fromIndex, 1);
+        this._rows.splice(toIndex, 0, movedRow);
+        if (!disablelObservation) {
+            this.dispatch(observeId);
+        }
+        return true;
+    }
+    // Meta Methods
+    setMeta(key, value, observe = true) {
+        this._meta.set(key, this._meta_schema ? this._meta_schema[key].parse(value) : value);
+        observe && this.dispatch();
+    }
+    getMeta(key, observe = true) {
+        observe && this.observe();
+        return this._meta.get(key);
+    }
+    deleteMeta(key, observe = true) {
+        this._meta.delete(key);
+        observe && this.dispatch();
+    }
+    clearMeta(observe = true) {
+        this._meta.clear();
+        observe && this.dispatch();
+    }
 }
 
 export { Store as default };