@verdant-web/common 1.11.0 → 1.11.1

package/dist/cjs/operation.d.ts

@@ -1,139 +1,139 @@
-import { DocumentBaseline } from './baseline.js';
-import { FileRef } from './files.js';
-import { KeyPath, ObjectIdentifier } from './oids.js';
-export declare type ObjectRef = {
-    '@@type': 'ref';
-    id: ObjectIdentifier;
-};
-export declare function isObjectRef(obj: any): obj is ObjectRef;
-export declare type Normalized<T> = {
-    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
-};
-export declare type PropertyName = string | number;
-/**
- * List patches can target a particular child list or
- * nested lists. The first path item is the property path
- * of the first child list, any subsequent values are nested
- * list indices.
- */
-export declare type PropertyValue = string | number | boolean | null | undefined | ObjectRef;
-interface BaseOperationPatch {
-}
-export interface OperationPatchInitialize extends BaseOperationPatch {
-    op: 'initialize';
-    value: any;
-}
-export interface OperationPatchSet extends BaseOperationPatch {
-    op: 'set';
-    name: PropertyName;
-    value: PropertyValue;
-}
-export interface OperationPatchRemove extends BaseOperationPatch {
-    op: 'remove';
-    name: PropertyName;
-}
-export interface OperationPatchListPush extends BaseOperationPatch {
-    op: 'list-push';
-    value: PropertyValue;
-}
-export interface OperationPatchListInsert extends BaseOperationPatch {
-    op: 'list-insert';
-    index: number;
-    value?: PropertyValue;
-    values?: PropertyValue[];
-}
-export interface OperationPatchListDelete extends BaseOperationPatch {
-    op: 'list-delete';
-    index: number;
-    count: number;
-}
-/**
- * Optimal for lists of object references. Moves
- * the selected item to the target index even if it
- * is not at the original index anymore.
- */
-export interface OperationPatchListMoveByRef extends BaseOperationPatch {
-    op: 'list-move-by-ref';
-    value: ObjectRef;
-    index: number;
-}
-/**
- * Suitable for any list move, whether object lists
- * or primitive lists.
- */
-export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
-    op: 'list-move-by-index';
-    from: number;
-    to: number;
-}
-/**
- * Removes all instances of the value from
- * the list. Good for set behavior or removing
- * a specific item even if it changes index
- * from conflicts.
- */
-export interface OperationPatchListRemove extends BaseOperationPatch {
-    op: 'list-remove';
-    value: PropertyValue;
-    only?: 'first' | 'last';
-}
-export interface OperationPatchListAdd extends BaseOperationPatch {
-    op: 'list-add';
-    value: PropertyValue;
-}
-export interface OperationPatchDelete extends BaseOperationPatch {
-    op: 'delete';
-}
-export declare type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd;
-export declare type Operation = {
-    oid: ObjectIdentifier;
-    timestamp: string;
-    data: OperationPatch;
-};
-export declare function diffToPatches<T extends {
-    [key: string]: any;
-} | any[]>(from: T, to: T, getNow: () => string, keyPath: KeyPath, createSubId?: () => string, patches?: Operation[], options?: {
-    /**
-     * If an object is merged with another and the new one does not
-     * have an OID assigned, assume it is the same identity as previous
-     */
-    mergeUnknownObjects?: boolean;
-    /**
-     * If an incoming value is not assigned on the new object, use the previous value.
-     * If false, undefined properties will erase the previous value.
-     */
-    defaultUndefined?: boolean;
-}): Operation[];
-export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
-/**
- * Takes a basic object and constructs a patch list to create it and
- * all of its nested objects.
- */
-export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
-export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
-export declare function groupPatchesByIdentifier(patches: Operation[]): Record<string, Operation[]>;
-export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
-export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline<any>[]>;
-export declare type NormalizedObject = {
-    [key: PropertyName]: PropertyValue;
-} | Array<PropertyValue>;
-/**
- * The incoming object should already be normalized!
- * This function will mutate the base object.
- */
-export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
-/**
- * Optionally supply a list to which any refs which
- * are removed during the patch will be appended.
- */
-deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
-export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
-/**
- * Mutates the original object in place. Returns all referenced
- * objects oids.
- */
-export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
-export declare function substituteFirstLevelObjectsWithRefs<Base extends {
-    [key: string]: any;
-} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
-export {};
+import { DocumentBaseline } from './baseline.js';
+import { FileRef } from './files.js';
+import { KeyPath, ObjectIdentifier } from './oids.js';
+export declare type ObjectRef = {
+    '@@type': 'ref';
+    id: ObjectIdentifier;
+};
+export declare function isObjectRef(obj: any): obj is ObjectRef;
+export declare type Normalized<T> = {
+    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
+};
+export declare type PropertyName = string | number;
+/**
+ * List patches can target a particular child list or
+ * nested lists. The first path item is the property path
+ * of the first child list, any subsequent values are nested
+ * list indices.
+ */
+export declare type PropertyValue = string | number | boolean | null | undefined | ObjectRef;
+interface BaseOperationPatch {
+}
+export interface OperationPatchInitialize extends BaseOperationPatch {
+    op: 'initialize';
+    value: any;
+}
+export interface OperationPatchSet extends BaseOperationPatch {
+    op: 'set';
+    name: PropertyName;
+    value: PropertyValue;
+}
+export interface OperationPatchRemove extends BaseOperationPatch {
+    op: 'remove';
+    name: PropertyName;
+}
+export interface OperationPatchListPush extends BaseOperationPatch {
+    op: 'list-push';
+    value: PropertyValue;
+}
+export interface OperationPatchListInsert extends BaseOperationPatch {
+    op: 'list-insert';
+    index: number;
+    value?: PropertyValue;
+    values?: PropertyValue[];
+}
+export interface OperationPatchListDelete extends BaseOperationPatch {
+    op: 'list-delete';
+    index: number;
+    count: number;
+}
+/**
+ * Optimal for lists of object references. Moves
+ * the selected item to the target index even if it
+ * is not at the original index anymore.
+ */
+export interface OperationPatchListMoveByRef extends BaseOperationPatch {
+    op: 'list-move-by-ref';
+    value: ObjectRef;
+    index: number;
+}
+/**
+ * Suitable for any list move, whether object lists
+ * or primitive lists.
+ */
+export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
+    op: 'list-move-by-index';
+    from: number;
+    to: number;
+}
+/**
+ * Removes all instances of the value from
+ * the list. Good for set behavior or removing
+ * a specific item even if it changes index
+ * from conflicts.
+ */
+export interface OperationPatchListRemove extends BaseOperationPatch {
+    op: 'list-remove';
+    value: PropertyValue;
+    only?: 'first' | 'last';
+}
+export interface OperationPatchListAdd extends BaseOperationPatch {
+    op: 'list-add';
+    value: PropertyValue;
+}
+export interface OperationPatchDelete extends BaseOperationPatch {
+    op: 'delete';
+}
+export declare type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd;
+export declare type Operation = {
+    oid: ObjectIdentifier;
+    timestamp: string;
+    data: OperationPatch;
+};
+export declare function diffToPatches<T extends {
+    [key: string]: any;
+} | any[]>(from: T, to: T, getNow: () => string, keyPath: KeyPath, createSubId?: () => string, patches?: Operation[], options?: {
+    /**
+     * If an object is merged with another and the new one does not
+     * have an OID assigned, assume it is the same identity as previous
+     */
+    mergeUnknownObjects?: boolean;
+    /**
+     * If an incoming value is not assigned on the new object, use the previous value.
+     * If false, undefined properties will erase the previous value.
+     */
+    defaultUndefined?: boolean;
+}): Operation[];
+export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
+export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
+export declare function groupPatchesByIdentifier(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline<any>[]>;
+export declare type NormalizedObject = {
+    [key: PropertyName]: PropertyValue;
+} | Array<PropertyValue>;
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
+export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
+export declare function substituteFirstLevelObjectsWithRefs<Base extends {
+    [key: string]: any;
+} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+export {};