teamplay 0.5.0-alpha.8 → 0.5.0

package/dist/orm/SignalBase.d.ts

@@ -2,7 +2,7 @@ import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from './signalS
 export { SEGMENTS, ARRAY_METHOD, GET, GETTERS, DEFAULT_GETTERS };
 export declare class Signal<TValue = unknown> extends Function {
     /** Fields that are treated as document ids and mirror the document id segment. */
-    static ID_FIELDS: readonly ["_id"];
+    static get ID_FIELDS(): import("./idFields.js").IdFields;
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS]: string[];
     /** Association metadata registered for this model class. */
@@ -45,6 +45,8 @@ export declare class Signal<TValue = unknown> extends Function {
      * @param fn Function to execute inside the batch.
      */
     batch<TResult>(fn: () => TResult): TResult;
+    close(): Promise<void>;
+    close(callback: (err?: unknown) => void): void;
     /**
      * Internal read hook used by `.get()` and `.peek()`.
      * @param method Storage read function to use for the current signal path.
@@ -54,6 +56,12 @@ export declare class Signal<TValue = unknown> extends Function {
     get(): TValue;
     /** Return document ids for a query or aggregation signal. */
     getIds(): string[];
+    /** Return query extra data, aggregation data, or undefined for ordinary signals. */
+    getExtra(): unknown;
+    /** Return a shallow copy of the current value. */
+    getCopy(): TValue;
+    /** Return a deep copy of the current value. */
+    getDeepCopy(): TValue;
     /** Read the current value without tracking it for reactive rendering. */
     peek(): TValue;
     /** Return the document id represented by this document signal. */
@@ -105,6 +113,18 @@ export declare class Signal<TValue = unknown> extends Function {
      * @param value New value to store at this signal path.
      */
     setReplace(value: TValue): Promise<void>;
+    /** Set the current value only when it is null or undefined. */
+    setNull(value: TValue): Promise<void>;
+    /** Replace the current value unless it is exactly equal to the new value. */
+    setDiff(value: TValue): Promise<void>;
+    /** Recursively diff objects and arrays at the current signal path. */
+    setDiffDeep(value: TValue): Promise<void>;
+    /**
+     * Set multiple object fields with per-key replace semantics.
+     * Unlike assign(), null is stored as null and undefined follows setReplace() semantics.
+     * @param object Object containing fields to set.
+     */
+    setEach(object: NonNullable<TValue> extends object ? Partial<NonNullable<TValue>> : never): Promise<void>;
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.

package/dist/orm/SignalBase.js

@@ -12,18 +12,16 @@
  * 3. If extremely late bindings are enabled, to prevent name collisions when accessing fields
  *    in the raw data tree which have the same name as signal's methods
  */
+import { raw } from '@nx-js/observer-util';
+import arrayDiff from 'arraydiff';
 import uuid from '@teamplay/utils/uuid';
 import { get as _get, setPublicDoc as _setPublicDoc, setPublicDocReplace as _setPublicDocReplace, del as _del, dataTreeRaw, getRaw, getLogicalRootSnapshot, incrementPublic as _incrementPublic, arrayPushPublic as _arrayPushPublic, arrayUnshiftPublic as _arrayUnshiftPublic, arrayInsertPublic as _arrayInsertPublic, arrayPopPublic as _arrayPopPublic, arrayShiftPublic as _arrayShiftPublic, arrayRemovePublic as _arrayRemovePublic, arrayMovePublic as _arrayMovePublic, stringInsertPublic as _stringInsertPublic, stringRemovePublic as _stringRemovePublic } from './dataTree.js';
 import getSignal, { rawSignal } from "./getSignal.js";
 import { docSubscriptions } from './Doc.js';
 import { IS_QUERY, HASH, QUERIES } from './Query.js';
-import { AGGREGATIONS, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
-import { ROOT_FUNCTION, ROOT_ID, getRoot } from "./Root.js";
-import { isPrivateMutationForbidden } from "./connection.js";
-import { DEFAULT_ID_FIELDS, getIdFieldsForSegments, isIdFieldPath, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
-import { isCompatEnv } from './compatEnv.js';
-import { resolveRefSegmentsSafe, resolveRefSignalSafe } from './Compat/refFallback.js';
-import { compatStartOnRoot, compatStopOnRoot, joinScopePath } from './Compat/startStopCompat.js';
+import { AGGREGATIONS, IS_AGGREGATION, getAggregationCollectionName, getAggregationDocId } from './Aggregation.js';
+import { ROOT_FUNCTION, ROOT_ID, closeRootSignal, getRoot } from "./Root.js";
+import { getDefaultIdFields, getIdFieldsForSegments, isIdFieldPath, isPlainObject, isPublicDocPath, normalizeIdFields, prepareAddPayload, resolveAddDocId } from "./idFields.js";
 import { runInBatch } from './batchScheduler.js';
 import { isPublicCollection } from "./signalPathKind.js";
 import { ARRAY_METHOD, DEFAULT_GETTERS, GET, GETTERS, SEGMENTS } from "./signalSymbols.js";
@@ -81,7 +79,6 @@ const SIGNAL_READ_CONTEXT = {
 const SIGNAL_VALUE_MUTATION_CONTEXT = {
     getOwningRootId: getSignalOwningRootId,
     isPublicCollection,
-    isPrivateMutationForbidden,
     setPublicDoc: _setPublicDoc,
     setPrivateData,
     deletePublicDoc(segments) {
@@ -91,7 +88,9 @@ const SIGNAL_VALUE_MUTATION_CONTEXT = {
 };
 export class Signal extends Function {
     /** Fields that are treated as document ids and mirror the document id segment. */
-    static ID_FIELDS = DEFAULT_ID_FIELDS;
+    static get ID_FIELDS() {
+        return getDefaultIdFields();
+    }
     /** Method names that keep method binding priority over child signal dot access. */
     static [GETTERS] = DEFAULT_GETTERS;
     /** Association metadata registered for this model class. */
@@ -181,6 +180,14 @@ export class Signal extends Function {
             throw Error('Signal.batch() expects a function argument');
         return runInBatch(fn);
     }
+    close(callback) {
+        if (arguments.length > 1)
+            throw Error('Signal.close() expects zero or one argument');
+        if (callback != null && typeof callback !== 'function') {
+            throw Error('Signal.close() expects callback to be a function');
+        }
+        return callback ? closeRootSignal(this, callback) : closeRootSignal(this);
+    }
     /**
      * Internal read hook used by `.get()` and `.peek()`.
      * @param method Storage read function to use for the current signal path.
@@ -202,6 +209,28 @@ export class Signal extends Function {
             throw Error('Signal.getIds() does not accept any arguments');
         return getSignalIds(this, SIGNAL_READ_CONTEXT);
     }
+    /** Return query extra data, aggregation data, or undefined for ordinary signals. */
+    getExtra() {
+        if (arguments.length > 0)
+            throw Error('Signal.getExtra() does not accept any arguments');
+        if (this[IS_AGGREGATION])
+            return this.get();
+        if (this[IS_QUERY])
+            return this.extra.get();
+        return undefined;
+    }
+    /** Return a shallow copy of the current value. */
+    getCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getCopy() does not accept any arguments');
+        return shallowCopy(this.get());
+    }
+    /** Return a deep copy of the current value. */
+    getDeepCopy() {
+        if (arguments.length > 0)
+            throw Error('Signal.getDeepCopy() does not accept any arguments');
+        return deepCopy(this.get());
+    }
     /** Read the current value without tracking it for reactive rendering. */
     peek() {
         if (arguments.length > 0)
@@ -284,14 +313,52 @@ export class Signal extends Function {
             }
             return;
         }
-        if (isPrivateMutationForbidden()) {
-            throw Error(`
-        Can't modify private collections data when 'publicOnly' is enabled.
-        On the server you can only work with public collections.
-      `);
-        }
         setReplacePrivateData(getSignalOwningRootId(this), segments, nextValue);
     }
+    /** Set the current value only when it is null or undefined. */
+    async setNull(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setNull() expects a single argument');
+        if (this.get() != null)
+            return;
+        await this.setReplace(value);
+    }
+    /** Replace the current value unless it is exactly equal to the new value. */
+    async setDiff(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setDiff() expects a single argument');
+        const before = this.peek();
+        if (racerEqual(before, value))
+            return;
+        await this.setReplace(value);
+    }
+    /** Recursively diff objects and arrays at the current signal path. */
+    async setDiffDeep(value) {
+        if (arguments.length > 1)
+            throw Error('Signal.setDiffDeep() expects a single argument');
+        await runInBatch(() => setDiffDeepOnSignal(this, value));
+    }
+    /**
+     * Set multiple object fields with per-key replace semantics.
+     * Unlike assign(), null is stored as null and undefined follows setReplace() semantics.
+     * @param object Object containing fields to set.
+     */
+    async setEach(object) {
+        if (arguments.length > 1)
+            throw Error('Signal.setEach() expects a single argument');
+        if (!object)
+            return;
+        if (typeof object !== 'object') {
+            throw Error('Signal.setEach() expects an object argument, got: ' + typeof object);
+        }
+        await runInBatch(async () => {
+            const promises = [];
+            for (const key of Object.keys(object)) {
+                promises.push(this[key].setReplace(object[key]));
+            }
+            await Promise.all(promises);
+        });
+    }
     /**
      * Set multiple object fields at once. Fields set to `null` or `undefined` are deleted.
      * @param value Object containing fields to set or delete.
@@ -510,8 +577,10 @@ export class Signal extends Function {
     async add(value) {
         if (arguments.length > 1)
             throw Error('Signal.add() expects a single argument');
-        const id = resolveAddDocId(value, uuid);
-        const idFields = getIdFieldsForSegments([this[SEGMENTS][0], id]);
+        const collection = this[SEGMENTS][0];
+        const collectionIdFields = getIdFieldsForSegments([collection, '']);
+        const id = resolveAddDocId(value, collectionIdFields, uuid);
+        const idFields = getIdFieldsForSegments([collection, id]);
         await this[id].set(prepareAddPayload(value, idFields, id));
         return id;
     }
@@ -522,6 +591,177 @@ export class Signal extends Function {
         await deleteSignalValue(this, SIGNAL_VALUE_MUTATION_CONTEXT);
     }
 }
+async function setDiffDeepOnSignal($target, value) {
+    if ($target[SEGMENTS].length === 0)
+        throw Error('Can\'t set the root signal data');
+    await diffDeepOnSignal($target, $target.peek(), value);
+}
+async function diffDeepOnSignal($signal, before, after) {
+    if (before === after)
+        return;
+    if (Array.isArray(before) && Array.isArray(after)) {
+        const diff = arrayDiff(before, after, deepEqual);
+        if (!diff.length)
+            return;
+        const index = getSingleArrayReplacementIndex(diff);
+        if (index != null) {
+            await diffDeepOnSignal(getChildSignal($signal, index), before[index], after[index]);
+            return;
+        }
+        await applyArrayDiff($signal, diff);
+        return;
+    }
+    if (isDiffableObject(before, after)) {
+        const preservePath = $signal[SEGMENTS];
+        for (const key of Object.keys(before)) {
+            if (Object.prototype.hasOwnProperty.call(after, key))
+                continue;
+            await deleteForDiffDeep(getChildSignal($signal, key), preservePath);
+        }
+        for (const key of Object.keys(after)) {
+            await diffDeepOnSignal(getChildSignal($signal, key), before[key], after[key]);
+        }
+        return;
+    }
+    await $signal.setReplace(after);
+}
+function isDiffableObject(before, after) {
+    if (!isPlainObject(before) || !isPlainObject(after))
+        return false;
+    if (isReactLike(before) || isReactLike(after))
+        return false;
+    return true;
+}
+function isReactLike(value) {
+    return !!(value && typeof value === 'object' && typeof value.$$typeof === 'symbol');
+}
+function getSingleArrayReplacementIndex(diff) {
+    if (!Array.isArray(diff) || diff.length !== 2)
+        return null;
+    const first = diff[0];
+    const second = diff[1];
+    if (first instanceof arrayDiff.RemoveDiff &&
+        second instanceof arrayDiff.InsertDiff &&
+        first.index === second.index &&
+        first.howMany === 1 &&
+        second.values.length === 1) {
+        return first.index;
+    }
+    return null;
+}
+async function applyArrayDiff($signal, diff) {
+    for (const item of diff) {
+        if (item instanceof arrayDiff.InsertDiff) {
+            await $signal.insert(item.index, item.values);
+            continue;
+        }
+        if (item instanceof arrayDiff.RemoveDiff) {
+            await $signal.remove(item.index, item.howMany);
+            continue;
+        }
+        if (item instanceof arrayDiff.MoveDiff) {
+            await $signal.move(item.from, item.to, item.howMany);
+        }
+    }
+}
+async function deleteForDiffDeep($signal, preservePath) {
+    const segments = $signal[SEGMENTS];
+    const idFields = getIdFieldsForSegments(segments);
+    if (isIdFieldPath(segments, idFields))
+        return;
+    if (isPublicCollection(segments[0])) {
+        await $signal.del();
+        return;
+    }
+    delPrivateData(getSignalOwningRootId($signal), segments, { preservePath });
+}
+function getChildSignal($parent, key) {
+    return getSignal(getRoot($parent) || $parent, [...$parent[SEGMENTS], key]);
+}
+function deepEqual(left, right) {
+    if (left === right)
+        return true;
+    if (left == null || right == null)
+        return false;
+    if (typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left)) {
+        if (left.length !== right.length)
+            return false;
+        for (let i = 0; i < left.length; i++) {
+            if (!deepEqual(left[i], right[i]))
+                return false;
+        }
+        return true;
+    }
+    if (!isPlainObject(left) || !isPlainObject(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key))
+            return false;
+        if (!deepEqual(left[key], right[key]))
+            return false;
+    }
+    return true;
+}
+function racerEqual(left, right) {
+    return left === right || (Number.isNaN(left) && Number.isNaN(right));
+}
+function shallowCopy(value) {
+    const rawValue = raw(value);
+    if (Array.isArray(rawValue))
+        return rawValue.slice();
+    if (rawValue && typeof rawValue === 'object')
+        return { ...rawValue };
+    return rawValue;
+}
+function deepCopy(value) {
+    const rawValue = raw(value);
+    if (!rawValue || typeof rawValue !== 'object')
+        return rawValue;
+    if (typeof globalThis.structuredClone === 'function') {
+        try {
+            return globalThis.structuredClone(rawValue);
+        }
+        catch { }
+    }
+    return racerDeepCopy(rawValue);
+}
+// Racer-style deep copy:
+// - Preserves prototypes by instantiating via `new value.constructor()`
+// - Copies own enumerable props recursively
+// - Keeps functions as-is (no cloning)
+// - Handles Date by creating a new Date
+// Limitations: does not handle cyclic refs, Map/Set/RegExp/TypedArray, non-enumerables.
+function racerDeepCopy(value) {
+    if (value instanceof Date)
+        return new Date(value);
+    if (typeof value === 'object') {
+        if (value === null)
+            return null;
+        if (Array.isArray(value)) {
+            const array = [];
+            for (let i = value.length; i--;) {
+                array[i] = racerDeepCopy(value[i]);
+            }
+            return array;
+        }
+        const object = new value.constructor();
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                object[key] = racerDeepCopy(value[key]);
+            }
+        }
+        return object;
+    }
+    return value;
+}
 // dot syntax returns a child signal only if no such method or property exists
 export const regularBindings = {
     apply(signal, thisArg, argumentsList) {
@@ -538,8 +778,7 @@ export const regularBindings = {
         return Reflect.apply(extremelyLateBindings.get, this, arguments);
     }
 };
-const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra', 'subscribe', 'unsubscribe', 'fetch', 'unfetch'];
-const AGGREGATION_ALLOWED_METHODS = ['subscribe', 'unsubscribe', 'fetch', 'unfetch', 'ref', 'removeRef', 'refExtra', 'refIds'];
+const QUERY_METHODS = ['map', 'reduce', 'find', 'get', 'getIds', 'getExtra'];
 // dot syntax always returns a child signal even if such method or property exists.
 // The method is only called when the signal is explicitly called as a function,
 // in which case we get the original method from the raw (non-proxied) parent signal
@@ -584,7 +823,7 @@ export const extremelyLateBindings = {
                     });
                 }
             }
-            else if (!DEFAULT_GETTERS.includes(key) && !AGGREGATION_ALLOWED_METHODS.includes(key)) {
+            else if (!DEFAULT_GETTERS.includes(key)) {
                 throw Error(ERRORS.aggregationSetter(segments, key));
             }
         }
@@ -592,42 +831,6 @@ export const extremelyLateBindings = {
         const rawParent = rawSignal($parent);
         if (key in rawParent)
             return Reflect.apply(rawParent[key], $parent, argumentsList);
-        if (isCompatEnv()) {
-            const $resolvedParent = resolveRefSignalSafe($parent);
-            if ($resolvedParent && $resolvedParent !== $parent) {
-                const rawResolvedParent = rawSignal($resolvedParent);
-                if (rawResolvedParent && key in rawResolvedParent) {
-                    return Reflect.apply(rawResolvedParent[key], $resolvedParent, argumentsList);
-                }
-            }
-            else {
-                const resolvedSegments = resolveRefSegmentsSafe(segments, (getRoot(signal) || signal)?.[ROOT_ID]);
-                if (resolvedSegments) {
-                    const $resolvedByPath = getSignal(getRoot(signal), resolvedSegments);
-                    const rawResolvedByPath = rawSignal($resolvedByPath);
-                    if (rawResolvedByPath && key in rawResolvedByPath) {
-                        return Reflect.apply(rawResolvedByPath[key], $resolvedByPath, argumentsList);
-                    }
-                }
-            }
-            if (key === 'start') {
-                const [relativePath, ...depsAndGetter] = argumentsList;
-                if (typeof relativePath !== 'string')
-                    throw Error('Signal.start() expects targetPath to be a string');
-                const absolutePath = joinScopePath($parent.path(), relativePath);
-                return compatStartOnRoot(getRoot($parent) || $parent, absolutePath, ...depsAndGetter);
-            }
-            if (key === 'stop') {
-                if (argumentsList.length > 1)
-                    throw Error('Signal.stop() expects zero or one argument');
-                const relativePath = argumentsList.length === 0 ? '' : argumentsList[0];
-                if (relativePath != null && typeof relativePath !== 'string') {
-                    throw Error('Signal.stop() expects targetPath to be a string');
-                }
-                const absolutePath = joinScopePath($parent.path(), relativePath || '');
-                return compatStopOnRoot(getRoot($parent) || $parent, absolutePath);
-            }
-        }
         throw Error(ERRORS.noSignalKey($parent, key));
     },
     get(signal, key, receiver) {

package/dist/orm/batchScheduler.d.ts

@@ -1,7 +1,7 @@
-export function beginBatch(): void;
-export function endBatch(): void;
-export function inBatch(): boolean;
-export function runInBatch(fn: any): any;
-export function scheduleReaction(reactionFn: any): void;
-export function flushReactions(): void;
-export function __resetBatchSchedulerForTests(): void;
+export function beginBatch (): void
+export function endBatch (): void
+export function inBatch (): boolean
+export function runInBatch<TResult> (fn: () => TResult): TResult
+export function scheduleReaction (reactionFn: () => unknown): void
+export function flushReactions (): void
+export function __resetBatchSchedulerForTests (): void

package/dist/orm/connection.d.ts

@@ -16,11 +16,7 @@ export interface TeamplayConnection {
     [key: string]: unknown;
 }
 export declare let connection: TeamplayConnection | undefined;
-export declare let publicOnly: boolean | undefined;
 export declare function setConnection(_connection: TeamplayConnection | undefined): void;
 export declare function getConnection(): TeamplayConnection;
 export declare function setDefaultFetchOnly(_fetchOnly: boolean): void;
 export declare function getDefaultFetchOnly(): boolean;
-export declare function setFetchOnly(_fetchOnly: boolean): void;
-export declare function setPublicOnly(_publicOnly: boolean): void;
-export declare function isPrivateMutationForbidden(): boolean;

package/dist/orm/connection.js

@@ -1,7 +1,5 @@
-import { isCompatEnv } from './compatEnv.js';
 export let connection;
 let defaultFetchOnly;
-export let publicOnly;
 export function setConnection(_connection) {
     connection = _connection;
 }
@@ -16,16 +14,6 @@ export function setDefaultFetchOnly(_fetchOnly) {
 export function getDefaultFetchOnly() {
     return !!defaultFetchOnly;
 }
-// Deprecated alias kept for internal transition.
-export function setFetchOnly(_fetchOnly) {
-    setDefaultFetchOnly(_fetchOnly);
-}
-export function setPublicOnly(_publicOnly) {
-    publicOnly = _publicOnly;
-}
-export function isPrivateMutationForbidden() {
-    return !!publicOnly && !isCompatEnv();
-}
 const ERRORS = {
     notSet: `
     Connection is not set.

package/dist/orm/dataTree.d.ts

@@ -4,18 +4,18 @@ export function getLogicalRootSnapshot(rootId: any, tree?: {}): {
 };
 export function get(segments: any, tree?: {}): {};
 export function getRaw(segments: any): {};
-export function set(segments: any, value: any, tree: {} | undefined, eventContext: any): void;
-export function setReplace(segments: any, value: any, tree: {} | undefined, eventContext: any): void;
-export function del(segments: any, tree: {} | undefined, eventContext: any): void;
+export function set(segments: any, value: any, tree?: {}): void;
+export function setReplace(segments: any, value: any, tree?: {}): void;
+export function del(segments: any, tree?: {}): void;
 export function setPublicDoc(segments: any, value: any, deleteValue?: boolean): Promise<any>;
 export function setPublicDocReplace(segments: any, value: any): Promise<any>;
-export function arrayPush(segments: any, value: any, tree: {} | undefined, eventContext: any): number;
-export function arrayUnshift(segments: any, value: any, tree: {} | undefined, eventContext: any): number;
-export function arrayInsert(segments: any, index: any, values: any, tree: {} | undefined, eventContext: any): number;
-export function arrayPop(segments: any, tree: {} | undefined, eventContext: any): any;
-export function arrayShift(segments: any, tree: {} | undefined, eventContext: any): any;
-export function arrayRemove(segments: any, index: any, howMany: number | undefined, tree: {} | undefined, eventContext: any): any[];
-export function arrayMove(segments: any, from: any, to: any, howMany: number | undefined, tree: {} | undefined, eventContext: any): any[];
+export function arrayPush(segments: any, value: any, tree?: {}): number;
+export function arrayUnshift(segments: any, value: any, tree?: {}): number;
+export function arrayInsert(segments: any, index: any, values: any, tree?: {}): number;
+export function arrayPop(segments: any, tree?: {}): any;
+export function arrayShift(segments: any, tree?: {}): any;
+export function arrayRemove(segments: any, index: any, howMany?: number, tree?: {}): any[];
+export function arrayMove(segments: any, from: any, to: any, howMany?: number, tree?: {}): any[];
 export function incrementPublic(segments: any, byNumber: any): Promise<any>;
 export function arrayPushPublic(segments: any, value: any): Promise<any>;
 export function arrayUnshiftPublic(segments: any, value: any): Promise<any>;
@@ -24,8 +24,8 @@ export function arrayPopPublic(segments: any): Promise<any>;
 export function arrayShiftPublic(segments: any): Promise<any>;
 export function arrayRemovePublic(segments: any, index: any, howMany?: number): Promise<any>;
 export function arrayMovePublic(segments: any, from: any, to: any, howMany?: number): Promise<any>;
-export function stringInsertLocal(segments: any, index: any, text: any, tree: {} | undefined, eventContext: any): any;
-export function stringRemoveLocal(segments: any, index: any, howMany: any, tree: {} | undefined, eventContext: any): any;
+export function stringInsertLocal(segments: any, index: any, text: any, tree?: {}): any;
+export function stringRemoveLocal(segments: any, index: any, howMany: any, tree?: {}): any;
 export function stringInsertPublic(segments: any, index: any, text: any): Promise<any>;
 export function stringRemovePublic(segments: any, index: any, howMany: any): Promise<any>;
 export { isPrivateCollectionSegments } from "./rootScope.js";