@shaxpir/duiduidui-models 1.0.0

package/dist/models/markup/Operation.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../../decs.d.ts" />
+import { Op as DeltaOp } from "@shaxpir/quill-delta";
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { Model } from '../content/Model';
+import { MultiTime } from '../content/Time';
+export type JsonPathElement = string | number;
+export type JsonPath = JsonPathElement[];
+export interface PathVal {
+    path: JsonPath;
+    val: any;
+}
+export declare class JsonPathSelect {
+    static getValueAtPath(doc: Doc, path: JsonPath): any;
+}
+export declare class BatchOperation {
+    private model;
+    private time;
+    private ops;
+    constructor(model: Model, time?: MultiTime);
+    get at(): MultiTime;
+    hasOps(): boolean;
+    editPathText(path: JsonPath, value: string): void;
+    setPathValue(path: JsonPath, value: any): void;
+    move(originPath: JsonPath, destinationPath: JsonPath): void;
+    insertIntoArray(arrayPath: JsonPath, index: number, value: any): void;
+    unshiftIntoArray(path: JsonPath, value: any): void;
+    pushIntoArray(path: JsonPath, value: any): void;
+    removeValueAtPath(path: JsonPath): void;
+    replaceValueAtPath(path: JsonPath, value: any): void;
+    applyRichText(path: JsonPath, deltaOps: DeltaOp[]): void;
+    commit(): void;
+}

package/dist/models/markup/Operation.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchOperation = exports.JsonPathSelect = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const Struct_1 = require("../../util/Struct");
+const Content_1 = require("../content/Content");
+const Time_1 = require("../content/Time");
+const TextEditOps_1 = require("./TextEditOps");
+const Json1 = __importStar(require("../../repo/PermissiveJson1"));
+const RichText = require('@shaxpir/rich-text');
+const UnicodeText = require('ot-text-unicode');
+;
+class JsonPathSelect {
+    static getValueAtPath(doc, path) {
+        let currentNode = doc.data;
+        for (let i = 0; i < path.length; i++) {
+            let pathElement = path[i];
+            if (currentNode !== undefined && currentNode !== null) {
+                if (typeof (pathElement) === "string" && currentNode.hasOwnProperty(pathElement)) {
+                    currentNode = currentNode[pathElement];
+                }
+                else if (typeof (pathElement) === "number" && currentNode.length > pathElement) {
+                    currentNode = currentNode[pathElement];
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else {
+                console.error(`no value at path ${JSON.stringify(path)} at index ${i} in object '${doc.collection}/${doc.id}' with value ${JSON.stringify(doc.data)}`);
+                break;
+            }
+        }
+        return currentNode;
+    }
+}
+exports.JsonPathSelect = JsonPathSelect;
+class BatchOperation {
+    // TODO: maybe just use the timestamp on the Content?
+    constructor(model, time) {
+        if (model.isForbidden) {
+            throw new Error(`cannot create a BatchOperation on forbidden model: ${model.compoundKey}`);
+        }
+        this.model = model;
+        if (time) {
+            this.time = time;
+        }
+        else {
+            this.time = Time_1.MultiClock.now();
+        }
+        this.ops = [];
+    }
+    get at() {
+        return Struct_1.Struct.clone(this.time);
+    }
+    hasOps() {
+        return this.ops.length > 0;
+    }
+    editPathText(path, value) {
+        const prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (prevValue !== undefined) {
+            // If we're trying to edit a text value, but the previous value is null, then the
+            // 'editOp' will throw an exception. So we need to use a 'replaceOp' instead.
+            if (prevValue === null) {
+                this.ops.push(Json1.replaceOp(path, prevValue, value));
+            }
+            else if (!Struct_1.Struct.equals(prevValue, value)) {
+                const textEditOps = TextEditOps_1.TextEditOps.between(prevValue, value);
+                this.ops.push(Json1.editOp(path, UnicodeText.type, textEditOps));
+            }
+        }
+        else {
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    setPathValue(path, value) {
+        const prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (prevValue !== undefined) {
+            if (!Struct_1.Struct.equals(prevValue, value)) {
+                this.ops.push(Json1.replaceOp(path, prevValue, value));
+            }
+        }
+        else {
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    move(originPath, destinationPath) {
+        this.ops.push(Json1.moveOp(originPath, destinationPath));
+    }
+    insertIntoArray(arrayPath, index, value) {
+        let array = JsonPathSelect.getValueAtPath(this.model.doc, arrayPath);
+        if (array === undefined) {
+            this.ops.push(Json1.insertOp(arrayPath, [value]));
+        }
+        else {
+            if (!Array.isArray(array)) {
+                throw new Error(`path '${JSON.stringify(arrayPath)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+            }
+            const path = Struct_1.Struct.clone(arrayPath);
+            path.push(index);
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    unshiftIntoArray(path, value) {
+        path = Struct_1.Struct.clone(path);
+        let array = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (array === undefined) {
+            this.ops.push(Json1.insertOp(path, [value]));
+        }
+        else {
+            if (!Array.isArray(array)) {
+                throw new Error(`path '${JSON.stringify(path)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+            }
+            path.push(0);
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    pushIntoArray(path, value) {
+        path = Struct_1.Struct.clone(path);
+        let array = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (array === undefined) {
+            this.ops.push(Json1.insertOp(path, [value]));
+        }
+        else {
+            if (!Array.isArray(array)) {
+                throw new Error(`path '${JSON.stringify(path)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+            }
+            path.push(array.length);
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    removeValueAtPath(path) {
+        let prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (prevValue !== undefined) {
+            this.ops.push(Json1.removeOp(path, prevValue));
+        }
+    }
+    replaceValueAtPath(path, value) {
+        let prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+        if (prevValue !== undefined) {
+            this.ops.push(Json1.replaceOp(path, prevValue, value));
+        }
+        else {
+            this.ops.push(Json1.insertOp(path, value));
+        }
+    }
+    applyRichText(path, deltaOps) {
+        this.ops.push(Json1.editOp(path, RichText.type, deltaOps));
+    }
+    commit() {
+        const batch = this;
+        if (batch.ops.length > 0) {
+            // Update the timestamp of the model (omitting local-time for Manifest objects (which are not Content)).
+            this.setPathValue(['meta', 'updated_at', 'utc_time'], batch.time.utc_time);
+            if (batch.model instanceof Content_1.Content) {
+                this.setPathValue(['meta', 'updated_at', 'local_time'], batch.time.local_time);
+            }
+            const reduced = batch.ops.reduce(Json1.type.compose, null);
+            const shareSync = ShareSync_1.ShareSyncFactory.get();
+            batch.model.doc.submitOp(reduced, (error) => {
+                if (error) {
+                    shareSync.onOperationError(error);
+                }
+            });
+            if (batch.model instanceof Content_1.Content) {
+                batch.model.modelUpdated();
+            }
+        }
+    }
+}
+exports.BatchOperation = BatchOperation;

package/dist/models/markup/TextEditOps.d.ts

@@ -0,0 +1,9 @@
+export type TextEditRetainOp = number;
+export type TextEditInsertOp = string;
+export interface TextEditDeleteOp {
+    d: number | String;
+}
+export type TextEditOp = TextEditRetainOp | TextEditInsertOp | TextEditDeleteOp;
+export declare class TextEditOps {
+    static between(before: string, after: string): TextEditOp[];
+}

package/dist/models/markup/TextEditOps.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEditOps = void 0;
+const fast_array_diff_1 = require("fast-array-diff");
+;
+class TextEditOps {
+    static between(before, after) {
+        let ops = [];
+        if (before.length === 0 && after.length === 0) {
+            return ops;
+        }
+        else if (before.length === 0) {
+            ops.push(after);
+        }
+        else if (after.length === 0) {
+            ops.push({ d: before });
+        }
+        else {
+            // First, we split the string into unicode characters. We use this method of splitting (regex with 'u' flag)
+            // in order to split on actual unicode characters, rather than merely on bytes. Even the String.charAt()
+            // function can't be trusted to handle multi-byte characters correctly (e.g., emojis). For more info, read here:
+            // https://stackoverflow.com/questions/35223206/how-to-split-unicode-string-to-characters-in-javascript
+            const beforeChars = before.match(/./ug);
+            const afterChars = after.match(/./ug);
+            // Create a diff-patch between these two character arrays.
+            let patch = (0, fast_array_diff_1.getPatch)(beforeChars, afterChars);
+            // console.log(JSON.stringify(patch));
+            let cursor = 0;
+            // Iterate through the patch items, and use them to construct OT operations, in the format expected by ShareDB.
+            for (let i = 0; i < patch.length; i++) {
+                const item = patch[i];
+                const chunk = item.items.join('');
+                if (item.oldPos > cursor) {
+                    const charsToRetain = item.oldPos - cursor;
+                    ops.push(charsToRetain);
+                    cursor += charsToRetain;
+                }
+                if (item.type == 'add') {
+                    ops.push(chunk);
+                }
+                else if (item.type == 'remove') {
+                    ops.push({ d: chunk });
+                    cursor += chunk.length;
+                }
+            }
+        }
+        return ops;
+    }
+}
+exports.TextEditOps = TextEditOps;

package/dist/models/markup/index.d.ts

@@ -0,0 +1,6 @@
+export * from './BodyFormat';
+export * from './ChangeModel';
+export * from './DeltaOps';
+export * from './HtmlMarkup';
+export * from './Operation';
+export * from './TextEditOps';

package/dist/models/markup/index.js

@@ -0,0 +1,23 @@
+"use strict";
+// created from 'create-ts-index'
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BodyFormat"), exports);
+__exportStar(require("./ChangeModel"), exports);
+__exportStar(require("./DeltaOps"), exports);
+__exportStar(require("./HtmlMarkup"), exports);
+__exportStar(require("./Operation"), exports);
+__exportStar(require("./TextEditOps"), exports);

package/dist/repo/ConnectionListener.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class ConnectionListener {
+    private _onSocketEvent;
+    constructor(onSocketEvent: (eventName: string, details: any) => void);
+    onSocketEvent(eventName: string, details: any): void;
+}
+export declare class NoOpConnectionListener extends ConnectionListener {
+    constructor();
+    static onSocketEvent(eventName: string, details: any): void;
+}

package/dist/repo/ConnectionListener.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpConnectionListener = exports.ConnectionListener = void 0;
+class ConnectionListener {
+    constructor(onSocketEvent) {
+        this._onSocketEvent = onSocketEvent;
+    }
+    onSocketEvent(eventName, details) {
+        this._onSocketEvent(eventName, details);
+    }
+}
+exports.ConnectionListener = ConnectionListener;
+class NoOpConnectionListener extends ConnectionListener {
+    constructor() {
+        super(NoOpConnectionListener.onSocketEvent);
+    }
+    static onSocketEvent(eventName, details) {
+        // DO NOTHING
+    }
+}
+exports.NoOpConnectionListener = NoOpConnectionListener;

package/dist/repo/PermissiveJson1.d.ts

@@ -0,0 +1,58 @@
+import * as Json1 from 'ot-json1';
+export * from 'ot-json1';
+export declare const type: {
+    transform(op1: Json1.JSONOpList, op2: Json1.JSONOpList, side: "left" | "right"): Json1.JSONOpList;
+    name: string;
+    uri: string;
+    readCursor: (op: Json1.JSONOpList) => Json1.ReadCursor;
+    writeCursor: () => Json1.WriteCursor;
+    create(data: Json1.Doc): Json1.Doc;
+    isNoop(op: Json1.JSONOpList): boolean;
+    setDebug(val: boolean): void;
+    registerSubtype: (subtype: {
+        [k: string]: any;
+        name: string;
+        uri?: string;
+        apply(doc: any, op: any): any;
+        compose(op1: any, op2: any): any;
+        transform(op1: any, op2: any, by: "left" | "right"): any;
+        isNoop?: (op: any) => boolean;
+        invert?: (op: any) => any;
+        makeInvertible?: (op: any, doc: any) => any;
+    } | {
+        [k: string]: any;
+        type: {
+            [k: string]: any;
+            name: string;
+            uri?: string;
+            apply(doc: any, op: any): any;
+            compose(op1: any, op2: any): any;
+            transform(op1: any, op2: any, by: "left" | "right"): any;
+            isNoop?: (op: any) => boolean;
+            invert?: (op: any) => any;
+            makeInvertible?: (op: any, doc: any) => any;
+        };
+    }) => void;
+    checkValidOp: (op: Json1.JSONOpList) => void;
+    normalize: (op: Json1.JSONOpList) => Json1.JSONOpList;
+    apply: (snapshot: Json1.Doc, op: Json1.JSONOpList) => string | number | boolean | {
+        [k: string]: Json1.Doc;
+    } | Json1.Doc[];
+    transformPosition: (path: Json1.Path, op: Json1.JSONOpList) => Json1.Path;
+    compose: (op1: Json1.JSONOpList, op2: Json1.JSONOpList) => Json1.JSONOpList;
+    tryTransform: (op1: Json1.JSONOpList, op2: Json1.JSONOpList, direction: "left" | "right") => {
+        ok: true;
+        result: Json1.JSONOpList;
+    } | {
+        ok: false;
+        conflict: Json1.Conflict;
+    };
+    makeInvertible: (op: Json1.JSONOpList, doc: Json1.Doc) => Json1.JSONOpList;
+    invert: (op: Json1.JSONOpList) => Json1.JSONOpList;
+    invertWithDoc: (op: Json1.JSONOpList, doc: Json1.Doc) => Json1.JSONOpList;
+    RM_UNEXPECTED_CONTENT: Json1.ConflictType;
+    DROP_COLLISION: Json1.ConflictType;
+    BLACKHOLE: Json1.ConflictType;
+    transformNoConflict: (op1: Json1.JSONOpList, op2: Json1.JSONOpList, side: "left" | "right") => Json1.JSONOpList;
+    typeAllowingConflictsPred: any;
+};

package/dist/repo/PermissiveJson1.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.type = void 0;
+const Json1 = __importStar(require("ot-json1"));
+__exportStar(require("ot-json1"), exports);
+// Export a version of ot-json1 that allows various conflicts
+exports.type = {
+    ...Json1.type.typeAllowingConflictsPred((conflict) => {
+        return (Json1.type.DROP_COLLISION === conflict.type
+            || Json1.type.BLACKHOLE === conflict.type
+            || Json1.type.RM_UNEXPECTED_CONTENT === conflict.type);
+    })
+};

package/dist/repo/ShareSync.d.ts

@@ -0,0 +1,60 @@
+import { Content, ContentBody, ContentId, ContentRef } from '../models/content/Content';
+import { ContentKind } from "../models/content/ContentKind";
+import { Manifest, ManifestBody } from '../models/content/Manifest';
+import { Model } from '../models/content/Model';
+import { CompactDateTime } from '../models/content/Time';
+import { ConnectionListener } from './ConnectionListener';
+import { Encryption } from '../util/Encryption';
+export declare enum ShareSyncDisposalStrategy {
+    UNSUBSCRIBE = 0,
+    DESTROY = 1,
+    NOTHING = 2
+}
+export interface ShareSyncOptions {
+    namespace: string;
+    debug: boolean;
+    disposalStrategy: ShareSyncDisposalStrategy;
+    connectionListener: ConnectionListener;
+    urlProvider: () => Promise<string>;
+    opErrorCallback: (error?: any) => void;
+    onReadyCallback?: () => void;
+    pingInterval?: number;
+    encryptionKey?: string;
+    webSocketConstructor?: any;
+}
+export declare class ShareSyncFactory {
+    private static INSTANCE;
+    static initialize(encryption: Encryption, options: ShareSyncOptions): void;
+    static get(): ShareSync;
+}
+export declare class ShareSync {
+    private _debug;
+    private _disposalStrategy;
+    private _opErrorCallback;
+    private _modelCache;
+    private _encryption;
+    private _hasDurableStore;
+    private _useDurableStoreEncryption;
+    private _durableStoreEncryptionKey;
+    private _socketIsOpen;
+    private _socket;
+    private _connection;
+    private _listener;
+    constructor(encryption: Encryption, options: ShareSyncOptions);
+    isDebug(): boolean;
+    isOnline(): boolean;
+    ping(): void;
+    makeContentId(): ContentId;
+    exists(userId: ContentId, kind: ContentKind, ref: ContentRef): Promise<boolean>;
+    createManifest(body: ManifestBody): Manifest;
+    createContent(body: ContentBody): Content;
+    acquire(kind: ContentKind, id: ContentId, timestamp?: CompactDateTime): Promise<Model>;
+    load(kind: ContentKind, id: ContentId): Model;
+    findAndAcquire(kind: ContentKind, query: any): Promise<Content[]>;
+    updateManifestForContent(content: Content): Promise<void>;
+    forEachOfflinePendingModel(callback: (kind: ContentKind, id: ContentId) => void): void;
+    isDocInInventory(kind: ContentKind, ref: ContentRef, minVersion?: CompactDateTime): boolean;
+    dispose(model: Model): void;
+    onOperationError(opError: any): void;
+    private wrap;
+}