@shaxpir/duiduidui-models 1.0.0

package/dist/repo/ShareSync.js

@@ -0,0 +1,348 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareSync = exports.ShareSyncFactory = exports.ShareSyncDisposalStrategy = void 0;
+const client_1 = __importStar(require("@shaxpir/sharedb/lib/client"));
+const reconnecting_websocket_1 = __importDefault(require("reconnecting-websocket"));
+const Billing_1 = require("../models/content/Billing");
+const Content_1 = require("../models/content/Content");
+const ContentKind_1 = require("../models/content/ContentKind");
+const Device_1 = require("../models/content/Device");
+const Manifest_1 = require("../models/content/Manifest");
+const Profile_1 = require("../models/content/Profile");
+const User_1 = require("../models/content/User");
+const Json1 = __importStar(require("./PermissiveJson1"));
+const RichText = require('@shaxpir/rich-text');
+const UnicodeText = require('ot-text-unicode');
+client_1.default.types.register(Json1.type);
+client_1.default.types.register(RichText.type);
+client_1.default.types.register(UnicodeText.type);
+Json1.type.registerSubtype(RichText.type);
+Json1.type.registerSubtype(UnicodeText.type);
+var ShareSyncDisposalStrategy;
+(function (ShareSyncDisposalStrategy) {
+    ShareSyncDisposalStrategy[ShareSyncDisposalStrategy["UNSUBSCRIBE"] = 0] = "UNSUBSCRIBE";
+    ShareSyncDisposalStrategy[ShareSyncDisposalStrategy["DESTROY"] = 1] = "DESTROY";
+    ShareSyncDisposalStrategy[ShareSyncDisposalStrategy["NOTHING"] = 2] = "NOTHING";
+})(ShareSyncDisposalStrategy || (exports.ShareSyncDisposalStrategy = ShareSyncDisposalStrategy = {}));
+class ShareSyncFactory {
+    static initialize(encryption, options) {
+        ShareSyncFactory.INSTANCE = new ShareSync(encryption, options);
+    }
+    static get() {
+        return ShareSyncFactory.INSTANCE;
+    }
+}
+exports.ShareSyncFactory = ShareSyncFactory;
+ShareSyncFactory.INSTANCE = null;
+class ShareSync {
+    constructor(encryption, options) {
+        this._modelCache = new Map();
+        const shareSync = this;
+        shareSync._encryption = encryption;
+        shareSync._debug = options.debug;
+        shareSync._disposalStrategy = options.disposalStrategy;
+        shareSync._opErrorCallback = options.opErrorCallback;
+        shareSync._hasDurableStore = options.namespace && options.namespace.length > 0;
+        shareSync._useDurableStoreEncryption = options.encryptionKey && options.encryptionKey.length > 0;
+        shareSync._durableStoreEncryptionKey = options.encryptionKey;
+        // Create and configure the socket.
+        if (options.webSocketConstructor) {
+            shareSync._socket = new reconnecting_websocket_1.default(options.urlProvider, [], { WebSocket: options.webSocketConstructor });
+        }
+        else {
+            shareSync._socket = new reconnecting_websocket_1.default(options.urlProvider);
+        }
+        function updateSocketIsOpen() {
+            shareSync._socketIsOpen = shareSync._socket.readyState === reconnecting_websocket_1.default.OPEN;
+        }
+        // The listener should forward all events: open, message, close, error
+        shareSync._listener = options.connectionListener;
+        shareSync._socket.addEventListener('open', (event) => {
+            updateSocketIsOpen();
+            shareSync._listener.onSocketEvent('open', event);
+        });
+        shareSync._socket.addEventListener('message', (event) => {
+            updateSocketIsOpen();
+            shareSync._listener.onSocketEvent('message', event);
+        });
+        shareSync._socket.addEventListener('close', (event) => {
+            updateSocketIsOpen();
+            shareSync._listener.onSocketEvent('close', event);
+        });
+        shareSync._socket.addEventListener('error', (event) => {
+            updateSocketIsOpen();
+            shareSync._listener.onSocketEvent('error', event);
+        });
+        // Create the ShareDB connection from the socket
+        if (shareSync._hasDurableStore) {
+            shareSync._connection = new client_1.Connection(shareSync._socket, {
+                durableStore: {
+                    namespace: options.namespace,
+                    debug: options.debug,
+                    useEncryption: shareSync._useDurableStoreEncryption,
+                    encryptionCallback: (plaintext) => {
+                        return encryption.encrypt(plaintext, shareSync._durableStoreEncryptionKey);
+                    },
+                    decryptionCallback: (cyphertext) => {
+                        return encryption.decrypt(cyphertext, shareSync._durableStoreEncryptionKey);
+                    },
+                    onReadyCallback: options.onReadyCallback,
+                    opErrorCallback: options.opErrorCallback,
+                    // Use the 'docData.meta.updated_at.utc_time' field (which is universal to all Model subclasses) as the 'version'
+                    // identifier that we use when determining if the doc in the DurableStore is up-to-date. This field won't yet
+                    // exist when the doc is newly created (since the 'doc.data' will be undefined), so in that case, we'll return
+                    // null as the version string, which will work correctly with the versioning semantics of the DurableStore.
+                    extVersionDecoder: (docData) => {
+                        if (docData &&
+                            docData.meta &&
+                            docData.meta.updated_at &&
+                            docData.meta.updated_at.utc_time) {
+                            return docData.meta.updated_at.utc_time;
+                        }
+                        return null;
+                    }
+                }
+            });
+        }
+        else {
+            shareSync._connection = new client_1.Connection(shareSync._socket);
+        }
+        shareSync._connection.on('error', (err) => {
+            console.error(`ShareSync connection error: ${err}\n  Error code: ${err.code}\n  Error message: ${err.message}\n  Error stack: ${err.stack}\n`);
+        });
+        // If the client provided a pingInterval option, then set up a periodic ping the
+        // connection alive. Clients who don't provide this option will send pings.
+        if (options.pingInterval && typeof (options.pingInterval) === 'number') {
+            setInterval(() => { shareSync.ping(); }, options.pingInterval);
+        }
+        if (!shareSync._hasDurableStore && !!options.onReadyCallback) {
+            // If there is no DurableStore, then we can call the onReadyCallback now. However,
+            // we have to use setTimeout to invoke it, because the callback will probably want
+            // to retrieve the ShareSync instance from the factory, and because the constructor
+            // hasn't actually finished yet, the INSTANCE pointer hasn't quite been assigned yet.
+            setTimeout(options.onReadyCallback, 1);
+        }
+    }
+    isDebug() {
+        return this._debug;
+    }
+    isOnline() {
+        return this._socketIsOpen;
+    }
+    ping() {
+        try {
+            this._connection.ping();
+        }
+        catch (error) {
+            // Ignore the error. We aren't directly concerned with the connection status.
+            // We just need to provoke the connection to attempt sending a ping message,
+            // so that if it fails to send that message, our normal socket-event listeners
+            // will notice the change in status, and trigger our downstream logic for
+            // displaying the offline status to the user.
+        }
+    }
+    makeContentId() {
+        return this._encryption.getRandomString(Content_1.Content.ID_LENGTH);
+    }
+    async exists(userId, kind, ref) {
+        // Check to see if this item exists in the model cache
+        const compoundKey = `${kind}/${ref}`;
+        if (this._modelCache.has(compoundKey)) {
+            const model = this._modelCache.get(compoundKey);
+            return model.exists();
+        }
+        // Check to see if this item exists in the durable-store inventory
+        const existsInDurableStore = this._connection.isDocInInventory(kind, ref);
+        if (existsInDurableStore) {
+            return true;
+        }
+        // Check to see if this item is recorded in the manifest.
+        const manifestId = Manifest_1.Manifest.makeManifestId(userId);
+        const manifest = this.load(ContentKind_1.ContentKind.MANIFEST, manifestId);
+        await manifest.acquire();
+        const existsInManifest = manifest.doesContentExist(kind, ref);
+        manifest.release();
+        if (existsInManifest) {
+            return true;
+        }
+        // Fetch this model from from the remote ShareDB server.
+        const model = this.load(kind, ref);
+        await model.acquire();
+        const exists = model.exists();
+        model.release();
+        return exists;
+    }
+    createManifest(body) {
+        const shareSync = this;
+        // Create or retrieve the doc object for this manifest model.
+        const manifestId = Manifest_1.Manifest.makeManifestId(body.meta.owner);
+        const doc = shareSync._connection.get(ContentKind_1.ContentKind.MANIFEST, manifestId);
+        doc.create(body, Json1.type.uri, (createErr) => {
+            if (createErr) {
+                console.log(`error creating manifest ${manifestId}: ${createErr}`);
+            }
+        });
+        shareSync.isDebug() && console.log(`created manifest ${manifestId}`);
+        const manifest = shareSync.wrap(ContentKind_1.ContentKind.MANIFEST, doc, true);
+        this._modelCache.set(manifest.compoundKey, manifest);
+        return manifest;
+    }
+    createContent(body) {
+        const shareSync = this;
+        // Create or retrieve the doc object for this content model.
+        const compoundKey = `${body.meta.kind}/${body.meta.ref}`;
+        const doc = shareSync._connection.get(body.meta.kind, body.meta.ref);
+        doc.create(body, Json1.type.uri, (createErr) => {
+            if (createErr) {
+                console.log(`error creating content ${compoundKey}: ${createErr}`);
+            }
+        });
+        shareSync.isDebug() && console.log(`created content ${compoundKey}`);
+        const content = shareSync.wrap(body.meta.kind, doc, true);
+        this._modelCache.set(compoundKey, content);
+        this.updateManifestForContent(content);
+        return content;
+    }
+    async acquire(kind, id, timestamp) {
+        let model = this.load(kind, id);
+        if (timestamp) {
+            model = await model.acquire(timestamp);
+        }
+        else {
+            model = await model.acquire();
+        }
+        return model;
+    }
+    load(kind, id) {
+        // First, try getting the content from the cache
+        const compoundKey = `${kind}/${id}`;
+        if (this._modelCache.has(compoundKey)) {
+            return this._modelCache.get(compoundKey);
+        }
+        // If not in the cache, get the model doc from the connection.
+        // Then wrap it and put it in the cache for future reference.
+        const doc = this._connection.get(kind, id);
+        const model = this.wrap(kind, doc, false);
+        this._modelCache.set(compoundKey, model);
+        return model;
+    }
+    async findAndAcquire(kind, query) {
+        const shareSync = this;
+        return new Promise((resolve, reject) => {
+            shareSync._connection.createFetchQuery(kind, query, {}, (error, results) => {
+                if (error) {
+                    const message = `query error (${error.code}): ${error.message}`;
+                    console.log(message);
+                    reject(message);
+                    return;
+                }
+                const contents = [];
+                for (let i = 0; i < results.length; i++) {
+                    const doc = results[i];
+                    if (doc.type) {
+                        const compoundKey = `${doc.collection}/${doc.id}`;
+                        if (shareSync._modelCache.has(compoundKey)) {
+                            const content = shareSync._modelCache.get(compoundKey);
+                            content.acquire();
+                            contents.push(content);
+                        }
+                        else {
+                            // NOTE: the wrap method calls 'acquire' on the model, so we don't need to do it here.
+                            const content = shareSync.wrap(kind, doc, true);
+                            shareSync._modelCache.set(compoundKey, content);
+                            contents.push(content);
+                        }
+                    }
+                }
+                resolve(contents);
+            });
+        });
+    }
+    async updateManifestForContent(content) {
+        // TODO: how will we handle manifest updates in a sharing scenario?
+        // If user A owns a book, and gives B permission to edit that book, and then B makes some
+        // changes to the book. We want B to be able to update their own manifest, but not the
+        // manifest belonging to A. But then how will A know that the book has been updated?
+        this.isDebug() && console.log(`updating manifest for content: ${content.compoundKey}`);
+        content.acquire();
+        const manifestId = Manifest_1.Manifest.makeManifestId(content.owner);
+        const manifest = this.load(ContentKind_1.ContentKind.MANIFEST, manifestId);
+        await manifest.acquire();
+        manifest.update(content);
+        manifest.release();
+        content.release();
+    }
+    forEachOfflinePendingModel(callback) {
+        this._connection.forEachPendingDocCollectionId(callback);
+    }
+    isDocInInventory(kind, ref, minVersion) {
+        // Check to see if this doc is in the DurableStore inventory. And if so, does it have a `minVersion`
+        // greater than or equal to the supplied `minVersion`. In all shaxpir models, the `minVersion` is
+        // extracted from the `meta.updated_at.utc_time` field.
+        return this._connection.isDocInInventory(kind, ref, minVersion);
+    }
+    dispose(model) {
+        if (this._disposalStrategy == ShareSyncDisposalStrategy.NOTHING) {
+            return;
+        }
+        // Remove the model from the cache
+        const compoundKey = model.compoundKey;
+        this._modelCache.delete(compoundKey);
+        // Dispose of the model's doc object
+        if (this._disposalStrategy == ShareSyncDisposalStrategy.DESTROY) {
+            model.disposeAndDestroy();
+        }
+        else if (this._disposalStrategy == ShareSyncDisposalStrategy.UNSUBSCRIBE) {
+            model.disposeAndUnsubscribe();
+        }
+    }
+    onOperationError(opError) {
+        this._opErrorCallback && this._opErrorCallback(opError);
+    }
+    wrap(kind, doc, shouldAcquire) {
+        const shareSync = this;
+        if (kind === ContentKind_1.ContentKind.MANIFEST) {
+            return new Manifest_1.Manifest(doc, shouldAcquire, shareSync);
+        }
+        else if (kind === ContentKind_1.ContentKind.USER) {
+            return new User_1.ModernUser(doc, shouldAcquire, shareSync);
+        }
+        else if (kind === ContentKind_1.ContentKind.DEVICE) {
+            return new Device_1.Device(doc, shouldAcquire, shareSync);
+        }
+        else if (kind === ContentKind_1.ContentKind.BILLING) {
+            return new Billing_1.Billing(doc, shouldAcquire, shareSync);
+        }
+        else if (kind === ContentKind_1.ContentKind.PROFILE) {
+            return new Profile_1.Profile(doc, shouldAcquire, shareSync);
+        }
+        throw new Error(`can't wrap content ${kind}/${doc.id}`);
+    }
+}
+exports.ShareSync = ShareSync;

package/dist/repo/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ConnectionListener';
+export * from './PermissiveJson1';
+export * from './ShareSync';

package/dist/repo/index.js

@@ -0,0 +1,20 @@
+"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("./ConnectionListener"), exports);
+__exportStar(require("./PermissiveJson1"), exports);
+__exportStar(require("./ShareSync"), exports);

package/dist/util/Async.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a promise that delays for the given ms before resolving.
+ *
+ * Intended to be used e.g. `await delay(1000)`
+ *
+ * @param t milliseconds to delay for
+ */
+export declare function delay(t: number): Promise<void>;

package/dist/util/Async.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+/**
+ * Returns a promise that delays for the given ms before resolving.
+ *
+ * Intended to be used e.g. `await delay(1000)`
+ *
+ * @param t milliseconds to delay for
+ */
+function delay(t) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, t);
+    });
+}
+exports.delay = delay;

package/dist/util/Base62.d.ts

@@ -0,0 +1,6 @@
+export declare class Base62 {
+    static readonly CHARS: string;
+    static encode(value: number, padToLength?: number): string;
+    static decode(value: string): number;
+    static fromHexHash(hex: string, length: number): string;
+}

package/dist/util/Base62.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base62 = void 0;
+class Base62 {
+    static encode(value, padToLength = 1) {
+        if (value < 0) {
+            throw new Error("number out of range: " + value);
+        }
+        let result = "";
+        while (value > 0) {
+            let index = value % 62;
+            let digit = Base62.CHARS.charAt(index);
+            result = digit + result;
+            value = Math.floor(value / 62);
+        }
+        while (result.length < padToLength) {
+            result = "0" + result;
+        }
+        return result;
+    }
+    static decode(value) {
+        let result = 0;
+        for (let i = 0, len = value.length; i < len; i++) {
+            let c = value.charAt(i);
+            result *= 62;
+            result += Base62.CHARS.indexOf(c);
+        }
+        return result;
+    }
+    static fromHexHash(hex, length) {
+        // NOTE: the crazy one-liner below is equivalent to this commented code...
+        //   const b64 = Buffer.from(hex, 'hex').toString('base64');
+        // ...but it doesn't require Buffer class, which is only available in Node.js, not in browsers.
+        // This one-liner came from stackoverflow: https://stackoverflow.com/questions/23190056/hex-to-base64-converter-for-javascript
+        const b64 = btoa(hex.match(/\w{2}/g).map((a) => { return String.fromCharCode(parseInt(a, 16)); }).join(""));
+        let alphanum = b64.replace(/[^a-zA-Z0-9]/g, "");
+        if (alphanum.length < length) {
+            alphanum = alphanum.padEnd(length, "0");
+        }
+        else if (alphanum.length > length) {
+            alphanum = alphanum.substring(0, length);
+        }
+        return alphanum;
+    }
+}
+exports.Base62 = Base62;
+Base62.CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

package/dist/util/BinarySearch.d.ts

@@ -0,0 +1,7 @@
+import { CompactDateTime } from "../models/content/Time";
+import { SpeechMarkItem } from "../models/content/Speech";
+export declare class BinarySearch {
+    static ofDateTimes(value: CompactDateTime, values: CompactDateTime[]): number;
+    static ofStrings(value: string, values: string[]): number;
+    static ofSpeechMarks(seekPoint: number, speechMarks: SpeechMarkItem[]): number;
+}

package/dist/util/BinarySearch.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinarySearch = void 0;
+class BinarySearch {
+    static ofDateTimes(value, values) {
+        return BinarySearch.ofStrings(value, values);
+    }
+    static ofStrings(value, values) {
+        let low = 0;
+        let high = values.length - 1;
+        while (low <= high) {
+            let mid = Math.floor((low + high) / 2);
+            let midValue = values[mid];
+            let comparison = midValue.localeCompare(value);
+            if (comparison < 0) {
+                low = mid + 1;
+            }
+            else if (comparison > 0) {
+                high = mid - 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return -(low + 1);
+    }
+    static ofSpeechMarks(seekPoint, speechMarks) {
+        let low = 0;
+        let high = speechMarks.length - 1;
+        while (low <= high) {
+            let mid = Math.floor((low + high) / 2);
+            let speechMark = speechMarks[mid];
+            if (speechMark.time < seekPoint) {
+                low = mid + 1;
+            }
+            else if (speechMark.time > seekPoint) {
+                high = mid - 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return low - 1;
+    }
+}
+exports.BinarySearch = BinarySearch;

package/dist/util/CachingHasher.d.ts

@@ -0,0 +1,8 @@
+import { ContentId } from '../models/content/Content';
+export declare class CachingHasher {
+    private static readonly MAX_SIZE;
+    private static md5HashLookup;
+    private static contentIdLookup;
+    static makeMd5Hash(text: string): string;
+    static makeMd5ContentId(text: string): ContentId;
+}

package/dist/util/CachingHasher.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingHasher = void 0;
+const md5_1 = __importDefault(require("md5"));
+const Base62_1 = require("./Base62");
+class CachingHasher {
+    static makeMd5Hash(text) {
+        if (CachingHasher.md5HashLookup.size > CachingHasher.MAX_SIZE) {
+            CachingHasher.md5HashLookup.clear();
+        }
+        if (CachingHasher.md5HashLookup.has(text)) {
+            return CachingHasher.md5HashLookup.get(text);
+        }
+        else {
+            const rawHash = (0, md5_1.default)(text);
+            this.md5HashLookup.set(text, rawHash);
+            return rawHash;
+        }
+    }
+    static makeMd5ContentId(text) {
+        if (CachingHasher.contentIdLookup.size > CachingHasher.MAX_SIZE) {
+            CachingHasher.contentIdLookup.clear();
+        }
+        if (CachingHasher.contentIdLookup.has(text)) {
+            return CachingHasher.contentIdLookup.get(text);
+        }
+        else {
+            const rawHash = (0, md5_1.default)(text);
+            const asBase62 = Base62_1.Base62.fromHexHash(rawHash, 16);
+            this.contentIdLookup.set(text, asBase62);
+            return asBase62;
+        }
+    }
+}
+exports.CachingHasher = CachingHasher;
+CachingHasher.MAX_SIZE = 1000;
+CachingHasher.md5HashLookup = new Map();
+CachingHasher.contentIdLookup = new Map();

package/dist/util/Color.d.ts

@@ -0,0 +1,32 @@
+export declare class RGB {
+    r: number;
+    g: number;
+    b: number;
+    constructor(r: number, g: number, b: number);
+    toHEX(): string;
+    toHSV(): HSV;
+    toHSLUV(): HSLUV;
+    static parse(color: string): RGB;
+}
+export declare class HSLUV {
+    h: number;
+    s: number;
+    l: number;
+    constructor(h: number, s: number, l: number);
+    toRGB(): RGB;
+}
+export declare class HSV {
+    h: number;
+    s: number;
+    v: number;
+    constructor(h: number, s: number, v: number);
+    toRGB(): RGB;
+}
+export declare class Color {
+    private static readonly EPSILON_SATURATION;
+    static normalize(color: string): string;
+    static makeShadeOf(color: string, hslOverride: {
+        [key: string]: number;
+    }): string;
+    static interpolate(loColor: string, hiColor: string, steps: number, percent: number): string;
+}