@loro-extended/change 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,339 @@
+import { LoroList, LoroMovableList, Container, LoroMap, Value, LoroText, LoroCounter, LoroTree, LoroDoc } from 'loro-crdt';
+
+type InferPlainType<T> = T extends Shape<infer P, any> ? P : never;
+type InferDraftType<T> = T extends Shape<any, infer D> ? D : never;
+type Draft<T extends DocShape<Record<string, ContainerShape>>> = InferDraftType<T>;
+
+type DraftNodeParams<Shape extends DocShape | ContainerShape> = {
+    shape: Shape;
+    emptyState?: InferPlainType<Shape>;
+    getContainer: () => ShapeToContainer<Shape>;
+};
+declare abstract class DraftNode<Shape extends DocShape | ContainerShape> {
+    protected _params: DraftNodeParams<Shape>;
+    protected _cachedContainer?: ShapeToContainer<Shape>;
+    constructor(_params: DraftNodeParams<Shape>);
+    abstract absorbPlainValues(): void;
+    protected get shape(): Shape;
+    protected get emptyState(): InferPlainType<Shape> | undefined;
+    protected get container(): ShapeToContainer<Shape>;
+}
+
+declare class CounterDraftNode extends DraftNode<CounterContainerShape> {
+    absorbPlainValues(): void;
+    increment(value: number): void;
+    decrement(value: number): void;
+    get value(): number;
+}
+
+declare abstract class ListDraftNodeBase<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"], DraftItem = NestedShape["_draft"]> extends DraftNode<any> {
+    private itemCache;
+    protected get container(): LoroList | LoroMovableList;
+    protected get shape(): ListContainerShape<NestedShape> | MovableListContainerShape<NestedShape>;
+    absorbPlainValues(): void;
+    protected abstract absorbValueAtIndex(index: number, value: any): void;
+    protected insertWithConversion(index: number, item: Item): void;
+    protected pushWithConversion(item: Item): void;
+    getDraftNodeParams(index: number, shape: ContainerShape): DraftNodeParams<ContainerShape>;
+    protected getPredicateItem(index: number): Item;
+    protected getDraftItem(index: number): DraftItem;
+    find(predicate: (item: Item, index: number) => boolean): DraftItem | undefined;
+    findIndex(predicate: (item: Item, index: number) => boolean): number;
+    map<ReturnType>(callback: (item: Item, index: number) => ReturnType): ReturnType[];
+    filter(predicate: (item: Item, index: number) => boolean): DraftItem[];
+    forEach(callback: (item: Item, index: number) => void): void;
+    some(predicate: (item: Item, index: number) => boolean): boolean;
+    every(predicate: (item: Item, index: number) => boolean): boolean;
+    insert(index: number, item: Item): void;
+    delete(index: number, len: number): void;
+    push(item: Item): void;
+    pushContainer(container: Container): Container;
+    insertContainer(index: number, container: Container): Container;
+    get(index: number): DraftItem;
+    toArray(): Item[];
+    get length(): number;
+    private updateCacheForDelete;
+    private updateCacheForInsert;
+}
+
+declare class ListDraftNode<NestedShape extends ContainerOrValueShape> extends ListDraftNodeBase<NestedShape> {
+    protected get container(): LoroList;
+    protected absorbValueAtIndex(index: number, value: any): void;
+}
+
+declare class MapDraftNode<NestedShapes extends Record<string, ContainerOrValueShape>> extends DraftNode<any> {
+    private propertyCache;
+    constructor(params: DraftNodeParams<MapContainerShape<NestedShapes>>);
+    protected get shape(): MapContainerShape<NestedShapes>;
+    protected get container(): LoroMap;
+    absorbPlainValues(): void;
+    getDraftNodeParams<S extends ContainerShape>(key: string, shape: S): DraftNodeParams<ContainerShape>;
+    getOrCreateNode<Shape extends ContainerShape | ValueShape>(key: string, shape: Shape): Shape extends ContainerShape ? DraftNode<Shape> : Value;
+    private createLazyProperties;
+    get(key: string): any;
+    set(key: string, value: Value): void;
+    setContainer<C extends Container>(key: string, container: C): C;
+    delete(key: string): void;
+    has(key: string): boolean;
+    keys(): string[];
+    values(): any[];
+    get size(): number;
+}
+
+declare class MovableListDraftNode<NestedShape extends ContainerOrValueShape, Item = NestedShape["_plain"]> extends ListDraftNodeBase<NestedShape> {
+    protected get container(): LoroMovableList;
+    protected absorbValueAtIndex(index: number, value: any): void;
+    move(from: number, to: number): void;
+    set(index: number, item: Exclude<Item, Container>): void;
+}
+
+declare class RecordDraftNode<NestedShape extends ContainerOrValueShape> extends DraftNode<any> {
+    private nodeCache;
+    constructor(params: DraftNodeParams<RecordContainerShape<NestedShape>>);
+    protected get shape(): RecordContainerShape<NestedShape>;
+    protected get container(): LoroMap;
+    absorbPlainValues(): void;
+    getDraftNodeParams<S extends ContainerShape>(key: string, shape: S): DraftNodeParams<ContainerShape>;
+    getOrCreateNode(key: string): InferDraftType<NestedShape>;
+    get(key: string): InferDraftType<NestedShape>;
+    set(key: string, value: any): void;
+    setContainer<C extends Container>(key: string, container: C): C;
+    delete(key: string): void;
+    has(key: string): boolean;
+    keys(): string[];
+    values(): any[];
+    get size(): number;
+}
+
+declare class TextDraftNode extends DraftNode<TextContainerShape> {
+    absorbPlainValues(): void;
+    insert(index: number, content: string): void;
+    delete(index: number, len: number): void;
+    toString(): string;
+    update(text: string): void;
+    mark(range: {
+        start: number;
+        end: number;
+    }, key: string, value: any): void;
+    unmark(range: {
+        start: number;
+        end: number;
+    }, key: string): void;
+    toDelta(): any[];
+    applyDelta(delta: any[]): void;
+    get length(): number;
+}
+
+interface DocShape<NestedShapes extends Record<string, ContainerShape> = Record<string, ContainerShape>> extends Shape<{
+    [K in keyof NestedShapes]: NestedShapes[K]["_plain"];
+}, {
+    [K in keyof NestedShapes]: NestedShapes[K]["_draft"];
+}> {
+    readonly _type: "doc";
+    readonly shapes: NestedShapes;
+}
+interface TextContainerShape extends Shape<string, TextDraftNode> {
+    readonly _type: "text";
+}
+interface CounterContainerShape extends Shape<number, CounterDraftNode> {
+    readonly _type: "counter";
+}
+interface TreeContainerShape<NestedShape = ContainerOrValueShape> extends Shape<any, any> {
+    readonly _type: "tree";
+    readonly shape: NestedShape;
+}
+interface ListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], ListDraftNode<NestedShape>> {
+    readonly _type: "list";
+    readonly shape: NestedShape;
+}
+interface MovableListContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<NestedShape["_plain"][], MovableListDraftNode<NestedShape>> {
+    readonly _type: "movableList";
+    readonly shape: NestedShape;
+}
+interface MapContainerShape<NestedShapes extends Record<string, ContainerOrValueShape> = Record<string, ContainerOrValueShape>> extends Shape<{
+    [K in keyof NestedShapes]: NestedShapes[K]["_plain"];
+}, MapDraftNode<NestedShapes> & {
+    [K in keyof NestedShapes]: NestedShapes[K]["_draft"];
+}> {
+    readonly _type: "map";
+    readonly shapes: NestedShapes;
+}
+interface RecordContainerShape<NestedShape extends ContainerOrValueShape = ContainerOrValueShape> extends Shape<Record<string, NestedShape["_plain"]>, RecordDraftNode<NestedShape>> {
+    readonly _type: "record";
+    readonly shape: NestedShape;
+}
+type ContainerShape = CounterContainerShape | ListContainerShape | MapContainerShape | MovableListContainerShape | RecordContainerShape | TextContainerShape | TreeContainerShape;
+type ContainerType = ContainerShape["_type"];
+interface StringValueShape extends Shape<string, string> {
+    readonly _type: "value";
+    readonly valueType: "string";
+}
+interface NumberValueShape extends Shape<number, number> {
+    readonly _type: "value";
+    readonly valueType: "number";
+}
+interface BooleanValueShape extends Shape<boolean, boolean> {
+    readonly _type: "value";
+    readonly valueType: "boolean";
+}
+interface NullValueShape extends Shape<null, null> {
+    readonly _type: "value";
+    readonly valueType: "null";
+}
+interface UndefinedValueShape extends Shape<undefined, undefined> {
+    readonly _type: "value";
+    readonly valueType: "undefined";
+}
+interface Uint8ArrayValueShape extends Shape<Uint8Array, Uint8Array> {
+    readonly _type: "value";
+    readonly valueType: "uint8array";
+}
+interface ObjectValueShape<T extends Record<string, ValueShape> = Record<string, ValueShape>> extends Shape<{
+    [K in keyof T]: T[K]["_plain"];
+}, {
+    [K in keyof T]: T[K]["_draft"];
+}> {
+    readonly _type: "value";
+    readonly valueType: "object";
+    readonly shape: T;
+}
+interface RecordValueShape<T extends ValueShape = ValueShape> extends Shape<Record<string, T["_plain"]>, Record<string, T["_draft"]>> {
+    readonly _type: "value";
+    readonly valueType: "record";
+    readonly shape: T;
+}
+interface ArrayValueShape<T extends ValueShape = ValueShape> extends Shape<T["_plain"][], T["_draft"][]> {
+    readonly _type: "value";
+    readonly valueType: "array";
+    readonly shape: T;
+}
+interface UnionValueShape<T extends ValueShape[] = ValueShape[]> extends Shape<T[number]["_plain"], T[number]["_draft"]> {
+    readonly _type: "value";
+    readonly valueType: "union";
+    readonly shapes: T;
+}
+type ValueShape = StringValueShape | NumberValueShape | BooleanValueShape | NullValueShape | UndefinedValueShape | Uint8ArrayValueShape | ObjectValueShape | RecordValueShape | ArrayValueShape | UnionValueShape;
+type ContainerOrValueShape = ContainerShape | ValueShape;
+interface Shape<Plain, Draft> {
+    readonly _type: string;
+    readonly _plain: Plain;
+    readonly _draft: Draft;
+}
+/**
+ * The LoroShape factory object
+ *
+ * If a container has a `shape` type variable, it refers to the shape it contains--
+ * so for example, a `LoroShape.list(LoroShape.text())` would return a value of type
+ * `ListContainerShape<TextContainerShape>`.
+ */
+declare const Shape: {
+    doc: <T extends Record<string, ContainerShape>>(shape: T) => DocShape<T>;
+    counter: () => CounterContainerShape;
+    list: <T extends ContainerOrValueShape>(shape: T) => ListContainerShape<T>;
+    map: <T extends Record<string, ContainerOrValueShape>>(shape: T) => MapContainerShape<T>;
+    record: <T extends ContainerOrValueShape>(shape: T) => RecordContainerShape<T>;
+    movableList: <T extends ContainerOrValueShape>(shape: T) => MovableListContainerShape<T>;
+    text: () => TextContainerShape;
+    tree: <T extends MapContainerShape>(shape: T) => TreeContainerShape;
+    plain: {
+        string: () => StringValueShape;
+        number: () => NumberValueShape;
+        boolean: () => BooleanValueShape;
+        null: () => NullValueShape;
+        undefined: () => UndefinedValueShape;
+        uint8Array: () => Uint8ArrayValueShape;
+        object: <T extends Record<string, ValueShape>>(shape: T) => ObjectValueShape<T>;
+        record: <T extends ValueShape>(shape: T) => RecordValueShape<T>;
+        array: <T extends ValueShape>(shape: T) => ArrayValueShape<T>;
+        union: <T extends ValueShape[]>(shapes: T) => UnionValueShape<T>;
+    };
+};
+type ShapeToContainer<T extends DocShape | ContainerShape> = T extends TextContainerShape ? LoroText : T extends CounterContainerShape ? LoroCounter : T extends ListContainerShape ? LoroList : T extends MovableListContainerShape ? LoroMovableList : T extends MapContainerShape | RecordContainerShape ? LoroMap : T extends TreeContainerShape ? LoroTree : never;
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: JSON Patch values can be any type */
+
+type JsonPatchAddOperation = {
+    op: "add";
+    path: string | (string | number)[];
+    value: any;
+};
+type JsonPatchRemoveOperation = {
+    op: "remove";
+    path: string | (string | number)[];
+};
+type JsonPatchReplaceOperation = {
+    op: "replace";
+    path: string | (string | number)[];
+    value: any;
+};
+type JsonPatchMoveOperation = {
+    op: "move";
+    path: string | (string | number)[];
+    from: string | (string | number)[];
+};
+type JsonPatchCopyOperation = {
+    op: "copy";
+    path: string | (string | number)[];
+    from: string | (string | number)[];
+};
+type JsonPatchTestOperation = {
+    op: "test";
+    path: string | (string | number)[];
+    value: any;
+};
+type JsonPatchOperation = JsonPatchAddOperation | JsonPatchRemoveOperation | JsonPatchReplaceOperation | JsonPatchMoveOperation | JsonPatchCopyOperation | JsonPatchTestOperation;
+type JsonPatch = JsonPatchOperation[];
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: fix later */
+
+declare class TypedDoc<Shape extends DocShape> {
+    private shape;
+    private emptyState;
+    private doc;
+    constructor(shape: Shape, emptyState: InferPlainType<Shape>, doc?: LoroDoc);
+    get value(): InferPlainType<Shape>;
+    change(fn: (draft: Draft<Shape>) => void): InferPlainType<Shape>;
+    /**
+     * Apply JSON Patch operations to the document
+     *
+     * @param patch - Array of JSON Patch operations (RFC 6902)
+     * @param pathPrefix - Optional path prefix for scoped operations
+     * @returns Updated document value
+     *
+     * @example
+     * ```typescript
+     * const result = typedDoc.applyPatch([
+     *   { op: 'add', path: '/users/0/name', value: 'Alice' },
+     *   { op: 'replace', path: '/settings/theme', value: 'dark' }
+     * ])
+     * ```
+     */
+    applyPatch(patch: JsonPatch, pathPrefix?: (string | number)[]): InferPlainType<Shape>;
+    get loroDoc(): LoroDoc;
+    get docShape(): Shape;
+    get rawValue(): any;
+}
+declare function createTypedDoc<Shape extends DocShape>(shape: Shape, emptyState: InferPlainType<Shape>, existingDoc?: LoroDoc): TypedDoc<Shape>;
+
+/**
+ * Overlays CRDT state with empty state defaults
+ */
+declare function overlayEmptyState<Shape extends DocShape>(shape: Shape, crdtValue: {
+    [key: string]: Value;
+}, emptyValue: {
+    [key: string]: Value;
+}): {
+    [key: string]: Value;
+};
+/**
+ * Merges individual CRDT values with empty state defaults
+ */
+declare function mergeValue<Shape extends ContainerShape | ValueShape>(shape: Shape, crdtValue: Value, emptyValue: Value): Value;
+
+/**
+ * Validates empty state against schema structure without using Zod
+ * Combines the functionality of createEmptyStateValidator and createValueValidator
+ */
+declare function validateEmptyState<T extends DocShape>(emptyState: unknown, schema: T): InferPlainType<T>;
+
+export { type ArrayValueShape, type ContainerOrValueShape, type ContainerShape, type CounterContainerShape, type DocShape, type Draft, type InferDraftType, type InferPlainType, type ListContainerShape, type MapContainerShape, type MovableListContainerShape, type RecordContainerShape, type RecordValueShape, type ContainerType as RootContainerType, Shape, type TextContainerShape, type TreeContainerShape, TypedDoc, type ValueShape, createTypedDoc, mergeValue, overlayEmptyState, validateEmptyState };