@shaxpir/duiduidui-models 1.0.0

package/dist/util/Color.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = exports.HSV = exports.HSLUV = exports.RGB = void 0;
+const hsluv_1 = require("hsluv");
+const NumberFormat_1 = require("./NumberFormat");
+class RGB {
+    constructor(r, g, b) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+    }
+    toHEX() {
+        return "#" +
+            NumberFormat_1.NumberFormat.asHex(this.r, 2) +
+            NumberFormat_1.NumberFormat.asHex(this.g, 2) +
+            NumberFormat_1.NumberFormat.asHex(this.b, 2);
+    }
+    toHSV() {
+        let r = this.r;
+        let g = this.g;
+        let b = this.b;
+        let max = Math.max(r, g, b);
+        let min = Math.min(r, g, b);
+        let d = max - min;
+        let h;
+        switch (max) {
+            case min:
+                h = 0;
+                break;
+            case r:
+                h = (g - b) + d * (g < b ? 6 : 0);
+                h /= 6 * d;
+                break;
+            case g:
+                h = (b - r) + d * 2;
+                h /= 6 * d;
+                break;
+            case b:
+                h = (r - g) + d * 4;
+                h /= 6 * d;
+                break;
+        }
+        let s = max === 0 ? 0 : d / max;
+        let v = max / 255;
+        return new HSV(h, s, v);
+    }
+    toHSLUV() {
+        const converter = new hsluv_1.Hsluv();
+        converter.rgb_r = this.r / 255;
+        converter.rgb_g = this.g / 255;
+        converter.rgb_b = this.b / 255;
+        converter.rgbToHsluv();
+        const h = converter.hsluv_h;
+        const s = converter.hsluv_s;
+        const l = converter.hsluv_l;
+        return new HSLUV(h, s, l);
+    }
+    static parse(color) {
+        // match RGB values formatted as "rgb(12,34,56)" (with optional whitespace)
+        let match = /^\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\s*$/i.exec(color);
+        if (match !== null) {
+            return new RGB(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
+        }
+        // match RGB values formatted as "#AABBCC" (with optional #hash prefix)
+        match = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color);
+        if (match !== null) {
+            return new RGB(parseInt(match[1], 16), parseInt(match[2], 16), parseInt(match[3], 16));
+        }
+        // match RGB values formatted as "#ABC" (with optional #hash prefix)
+        match = /^#?([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(color);
+        if (match !== null) {
+            const red = match[1] + match[1];
+            const grn = match[2] + match[2];
+            const blu = match[3] + match[3];
+            return new RGB(parseInt(red, 16), parseInt(grn, 16), parseInt(blu, 16));
+        }
+        throw Error("can\x27t parse color: " + color);
+    }
+}
+exports.RGB = RGB;
+// We get better interpolations by using a perceptually uniform color space...
+// https://programmingdesignsystems.com/color/perceptually-uniform-color-spaces/
+class HSLUV {
+    constructor(h, s, l) {
+        this.h = h;
+        this.s = s;
+        this.l = l;
+    }
+    toRGB() {
+        let h = this.h;
+        let s = this.s;
+        let l = this.l;
+        let converter = new hsluv_1.Hsluv();
+        converter.hsluv_h = h;
+        converter.hsluv_s = s;
+        converter.hsluv_l = l;
+        converter.hsluvToRgb();
+        let r = Math.round(converter.rgb_r * 255);
+        let g = Math.round(converter.rgb_g * 255);
+        let b = Math.round(converter.rgb_b * 255);
+        return new RGB(r, g, b);
+    }
+}
+exports.HSLUV = HSLUV;
+class HSV {
+    constructor(h, s, v) {
+        this.h = h;
+        this.s = s;
+        this.v = v;
+    }
+    toRGB() {
+        let h = this.h;
+        let s = this.s;
+        let v = this.v;
+        let i = Math.floor(h * 6);
+        let f = h * 6 - i;
+        let p = v * (1 - s);
+        let q = v * (1 - f * s);
+        let t = v * (1 - (1 - f) * s);
+        let r, g, b;
+        switch (i % 6) {
+            case 0:
+                r = v, g = t, b = p;
+                break;
+            case 1:
+                r = q, g = v, b = p;
+                break;
+            case 2:
+                r = p, g = v, b = t;
+                break;
+            case 3:
+                r = p, g = q, b = v;
+                break;
+            case 4:
+                r = t, g = p, b = v;
+                break;
+            case 5:
+                r = v, g = p, b = q;
+                break;
+        }
+        return new RGB(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
+    }
+}
+exports.HSV = HSV;
+class Color {
+    static normalize(color) {
+        let rgb = RGB.parse(color);
+        return rgb.toHEX();
+    }
+    static makeShadeOf(color, hslOverride) {
+        let rgb = RGB.parse(color);
+        let hsluv = rgb.toHSLUV();
+        if (hslOverride.hasOwnProperty("h")) {
+            hsluv.h = hslOverride.h;
+        }
+        if (hslOverride.hasOwnProperty("s")) {
+            hsluv.s = hslOverride.s;
+        }
+        if (hslOverride.hasOwnProperty("l")) {
+            hsluv.l = hslOverride.l;
+        }
+        rgb = hsluv.toRGB();
+        return rgb.toHEX();
+    }
+    static interpolate(loColor, hiColor, steps, percent) {
+        // NOTE: Unlike HSV (where all 3 values are floats between 0 and 1), the HSLUV color space
+        // has a hue value between 0 and 360, and saturation and lightness values between 0 and 100.
+        let loRGB = RGB.parse(loColor);
+        let hiRGB = RGB.parse(hiColor);
+        // There's no point interpolating if the number of steps is only 2.
+        if (steps === 2) {
+            return percent > 0.5 ? hiRGB.toHEX() : loRGB.toHEX();
+        }
+        let loHSLUV = loRGB.toHSLUV();
+        let hiHSLUV = hiRGB.toHSLUV();
+        // If one of the colors is completely desaturated, it should share the same hue as the other color
+        if (loHSLUV.s < Color.EPSILON_SATURATION)
+            loHSLUV.h = hiHSLUV.h;
+        if (hiHSLUV.s < Color.EPSILON_SATURATION)
+            hiHSLUV.h = loHSLUV.h;
+        let clockwiseDiff = (loHSLUV.h >= hiHSLUV.h) ? 1 + hiHSLUV.h - loHSLUV.h : hiHSLUV.h - loHSLUV.h;
+        let counterClockwiseDiff = (loHSLUV.h >= hiHSLUV.h) ? loHSLUV.h - hiHSLUV.h : 1 + loHSLUV.h - hiHSLUV.h;
+        // Quantize the percentage to a certain number of discreet color steps.
+        // We've already handled 2-step quantization above, and values less than 2
+        // are ignored because they don't make sense.
+        if (steps >= 3) {
+            percent = Math.round(percent * (steps - 1)) / (steps - 1);
+        }
+        // Interpolate the values
+        let h = (clockwiseDiff <= counterClockwiseDiff)
+            ? loHSLUV.h + (clockwiseDiff * percent)
+            : loHSLUV.h - (counterClockwiseDiff * percent);
+        if (h < 0)
+            h = 360 + h;
+        if (h > 360)
+            h = h - 360;
+        let s = (1 - percent) * loHSLUV.s + percent * hiHSLUV.s;
+        let l = (1 - percent) * loHSLUV.l + percent * hiHSLUV.l;
+        let rgb = new HSLUV(h, s, l).toRGB();
+        return rgb.toHEX();
+    }
+}
+exports.Color = Color;
+Color.EPSILON_SATURATION = 1.0;

package/dist/util/Dispatch.d.ts

@@ -0,0 +1,15 @@
+export type DispatchTopic = string;
+export type DispatchCallback = (topic: string, details?: any) => void;
+export interface DispatchMessage {
+    topic: DispatchTopic;
+    details?: any;
+}
+export declare class Dispatch {
+    private static debug;
+    private static readonly callbacksByTopic;
+    static setDebug(value: boolean): void;
+    static subscribe(topic: string, callback: DispatchCallback): void;
+    static unsubscribe(topic: DispatchTopic, callback: DispatchCallback): void;
+    static publish(topic: DispatchTopic, details?: any): Promise<void>;
+    static sequence(messages: DispatchMessage[]): Promise<void>;
+}

package/dist/util/Dispatch.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatch = void 0;
+class Dispatch {
+    static setDebug(value) {
+        Dispatch.debug = value;
+    }
+    static subscribe(topic, callback) {
+        let topicCallbacks = [];
+        if (Dispatch.callbacksByTopic.has(topic)) {
+            topicCallbacks = Dispatch.callbacksByTopic.get(topic);
+        }
+        else {
+            Dispatch.callbacksByTopic.set(topic, topicCallbacks);
+        }
+        topicCallbacks.push(callback);
+    }
+    static unsubscribe(topic, callback) {
+        if (Dispatch.callbacksByTopic.has(topic)) {
+            let topicCallbacks = [];
+            let newTopicCallbacks = [];
+            for (let i = 0, len = topicCallbacks.length; i < len; i++) {
+                let cb = topicCallbacks[i];
+                if (cb.toString() != callback.toString()) {
+                    newTopicCallbacks.push(callback);
+                }
+            }
+            if (newTopicCallbacks.length == 0) {
+                Dispatch.callbacksByTopic.delete(topic);
+            }
+            else {
+                Dispatch.callbacksByTopic.set(topic, newTopicCallbacks);
+            }
+        }
+    }
+    // Calls all the callbacks to this particular topic.  Returns a Promise which resolves when ALL
+    // of the topic callbacks have also resolved, or in the same event loop if they are synchronous.
+    static async publish(topic, details) {
+        if (Dispatch.callbacksByTopic.has(topic)) {
+            let topicCallbackResults = [];
+            let errors = [];
+            let subjectSubscribers = Dispatch.callbacksByTopic.get(topic);
+            if (Dispatch.debug) {
+                console.log(`Dispatching '${topic}' to ${subjectSubscribers.length} subscribers, with details: ${JSON.stringify(details)}`);
+            }
+            for (let i = 0, len = subjectSubscribers.length; i < len; i++) {
+                let callback = subjectSubscribers[i];
+                // catch errors here so we don't interrupt any of the other callbacks
+                let result;
+                try {
+                    result = callback(topic, details);
+                    topicCallbackResults.push(result);
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+            await Promise.all(topicCallbackResults);
+            if (errors.length > 0) {
+                return Promise.reject(errors);
+            }
+            return Promise.resolve();
+        }
+        else if (Dispatch.debug) {
+            console.log(`Dispatch has no subscribers to topic '${topic}'`);
+        }
+    }
+    // Fire off a sequence of messages.  Waits for the preceding message callbacks to finish / resolve
+    // before publishing the next (if the first message throws an exception, this short-circuits).
+    static async sequence(messages) {
+        for (let i = 0, len = messages.length; i < len; i++) {
+            let message = messages[i];
+            await Dispatch.publish(message.topic, message.details);
+        }
+    }
+}
+exports.Dispatch = Dispatch;
+Dispatch.debug = false;
+Dispatch.callbacksByTopic = new Map();

package/dist/util/EditDistance.d.ts

@@ -0,0 +1,13 @@
+export declare class EditDistance {
+    private static readonly CHARACTERS;
+    private static readonly FORBIDDEN_START_AND_END_CHARS;
+    static readonly ALWAYS_TRUE: (word: string) => boolean;
+    static of(s1: string, s2: string): number;
+    static permute(word: string, distance: number, predicate?: (word: string) => boolean): string[];
+    private static preFilterCandidate;
+    private static generateDeleteCandidates;
+    private static generateTransposeCandidates;
+    private static generateReplaceCandidates;
+    private static generateInsertCandidates;
+    private static collectCandidateIfPassPredicate;
+}

package/dist/util/EditDistance.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditDistance = void 0;
+const Struct_1 = require("../util/Struct");
+class EditDistance {
+    // This function copied from here:
+    // https://github.com/gustaveWPM/Typescript-Damerau-Levenshtein/blob/main/damerauLevenshtein.ts
+    // The algorithm is designed here:
+    // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
+    static of(s1, s2) {
+        if (s1 === s2)
+            return 0;
+        const [s1len, s2len] = [s1.length, s2.length];
+        const matrix = Array.from({ length: s1len + 1 }, () => new Array(s2len + 1).fill(0));
+        for (let y = 1; y <= s1len; y++)
+            matrix[y][0] = y;
+        for (let x = 1; x <= s2len; x++)
+            matrix[0][x] = x;
+        for (let y = 1; y <= s1len; y++) {
+            for (let x = 1; x <= s2len; x++) {
+                if (s1[y - 1] === s2[x - 1]) {
+                    matrix[y][x] = matrix[y - 1][x - 1];
+                }
+                else {
+                    matrix[y][x] =
+                        1 +
+                            Math.min(matrix[y - 1][x], matrix[y][x - 1], matrix[y - 1][x - 1]);
+                    if (y > 1 &&
+                        x > 1 &&
+                        s1[y - 1] === s2[x - 2] &&
+                        s1[y - 2] === s2[x - 1]) {
+                        matrix[y][x] = Math.min(matrix[y][x], matrix[y - 2][x - 2] + 1);
+                    }
+                }
+            }
+        }
+        return matrix[s1len][s2len];
+    }
+    static permute(word, distance, predicate) {
+        let roots = [word];
+        let predicateIsFunction = typeof (predicate) === "function";
+        let useDeferredPredicate = distance > 1 && predicateIsFunction;
+        let failed = {};
+        let candidates = {};
+        while (distance > 0) {
+            let p = distance > 1 || !predicateIsFunction
+                ? EditDistance.ALWAYS_TRUE
+                : predicate;
+            let lastGenCandidates = Struct_1.Struct.clone(candidates);
+            for (let i = 0, len = roots.length; i < len; i++) {
+                word = roots[i];
+                let wordLength = word.length;
+                EditDistance.generateDeleteCandidates(failed, candidates, p, word, wordLength);
+                EditDistance.generateTransposeCandidates(failed, candidates, p, word, wordLength);
+                EditDistance.generateReplaceCandidates(failed, candidates, p, word, wordLength);
+                EditDistance.generateInsertCandidates(failed, candidates, p, word, wordLength);
+            }
+            distance--;
+            if (distance === 0) {
+                if (useDeferredPredicate) {
+                    let confirmedCandidates = {};
+                    for (let candidate in candidates) {
+                        EditDistance.collectCandidateIfPassPredicate(failed, confirmedCandidates, candidate, predicate);
+                    }
+                    candidates = confirmedCandidates;
+                }
+            }
+            else {
+                roots = [];
+                for (let candidate in candidates) {
+                    if (!lastGenCandidates.hasOwnProperty(candidate)) {
+                        roots.push(candidate);
+                    }
+                }
+            }
+        }
+        return Object.keys(candidates);
+    }
+    static preFilterCandidate(failed, candidates, candidate, predicate) {
+        const firstChar = candidate.charAt(0);
+        const lastChar = candidate.charAt(candidate.length - 1);
+        if (!EditDistance.FORBIDDEN_START_AND_END_CHARS.includes(firstChar) && !EditDistance.FORBIDDEN_START_AND_END_CHARS.includes(lastChar)) {
+            EditDistance.collectCandidateIfPassPredicate(failed, candidates, candidate, predicate);
+        }
+    }
+    static generateDeleteCandidates(failed, candidates, predicate, word, len) {
+        if (len < 2) {
+            return;
+        }
+        let last = len - 1;
+        for (let i = 0; i < len; i++) {
+            let candidate;
+            if (i === 0) {
+                candidate = word.substring(1);
+            }
+            else if (i === last) {
+                candidate = word.substring(0, last);
+            }
+            else {
+                candidate = word.substring(0, i) + word.substring(i + 1, len);
+            }
+            EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
+        }
+    }
+    static generateTransposeCandidates(failed, candidates, predicate, word, len) {
+        if (len < 2) {
+            return;
+        }
+        else {
+            let last = len - 1;
+            for (let i = 0; i < last; i++) {
+                let textBefore = i === 0 ? "" : word.substring(0, i);
+                let a = word.charAt(i);
+                let b = word.charAt(i + 1);
+                let textAfter = i === last - 1 ? "" : word.substring(i + 2);
+                const candidate = textBefore + b + a + textAfter;
+                EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
+            }
+        }
+    }
+    static generateReplaceCandidates(failed, candidates, predicate, word, len) {
+        if (len < 2) {
+            return;
+        }
+        let last = len - 1;
+        for (let i = 0; i < len; i++) {
+            let charToReplace = word.charAt(i);
+            for (let j = 0, jLen = EditDistance.CHARACTERS.length; j < jLen; j++) {
+                let c = EditDistance.CHARACTERS[j];
+                if (c !== charToReplace) {
+                    let candidate;
+                    if (i === 0) {
+                        candidate = c + word.substring(1);
+                    }
+                    else if (i === last) {
+                        candidate = word.substring(0, last) + c;
+                    }
+                    else {
+                        candidate = word.substring(0, i) + c + word.substring(i + 1, len);
+                    }
+                    EditDistance.preFilterCandidate(failed, candidates, candidate, predicate);
+                }
+            }
+        }
+    }
+    static generateInsertCandidates(failed, candidates, predicate, word, len) {
+        for (let j = 0, jLen = EditDistance.CHARACTERS.length; j < jLen; j++) {
+            let c = EditDistance.CHARACTERS[j];
+            EditDistance.preFilterCandidate(failed, candidates, c + word, predicate);
+            for (let i = 1; i < len; i++) {
+                EditDistance.preFilterCandidate(failed, candidates, word.substring(0, i) + c + word.substring(i, len), predicate);
+            }
+            EditDistance.preFilterCandidate(failed, candidates, word + c, predicate);
+        }
+    }
+    static collectCandidateIfPassPredicate(failed, candidates, candidate, predicate) {
+        // If this candidate has failed, don't bother checking it again.
+        if (failed.hasOwnProperty(candidate)) {
+            return;
+        }
+        // If we've already collected this candidate, don't collect it again.
+        if (candidates.hasOwnProperty(candidate)) {
+            return;
+        }
+        if (!predicate(candidate)) {
+            failed[candidate] = candidate;
+            return;
+        }
+        candidates[candidate] = candidate;
+    }
+}
+exports.EditDistance = EditDistance;
+// This list of characters is used to generate candidates for the edit distance algorithm.
+// These characters exclude numerals, punctuation, and most non-English characters. However,
+// this list does include the characters çéñöü becuase they are common in English borrow-words
+// like "façade", "café", "jalapeño", and "über". This list also includes the hyphen and
+// apostrophe, which are common in English words. This list excludes characters that might
+// be common in proper names from non-English cultures, like "á", "í", "ó", "ú", "ý", "ÿ",
+// "â", "ê", "î", "ô", "û", so we will sometimes be unable to include those words in
+// spelling suggestions.
+EditDistance.CHARACTERS = "abcdefghijklmnopqrstuvwxyzçéñöü'-";
+// We don't allow words to start or end with a hyphen or apostrophe.
+EditDistance.FORBIDDEN_START_AND_END_CHARS = "-'";
+EditDistance.ALWAYS_TRUE = function () { return true; };

package/dist/util/Encryption.d.ts

@@ -0,0 +1,5 @@
+export interface Encryption {
+    getRandomString(length: number): string;
+    encrypt(cleartext: string, key: string): string;
+    decrypt(cyphertext: string, key: string): string;
+}

package/dist/util/Encryption.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/Logging.d.ts

@@ -0,0 +1,108 @@
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export type ClientType = 'user' | 'server' | 'desktop' | 'browser';
+export interface LogItem {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    fields: LogFields;
+}
+export interface LogRecorder {
+    recordLogEntry(item: LogItem): void;
+    inspect(err: any): string;
+}
+export declare abstract class ConsoleJsonLogRecorder implements LogRecorder {
+    abstract inspect(err: any): string;
+    recordLogEntry(item: LogItem): void;
+}
+export declare class Logger {
+    private recorder;
+    private timestamp;
+    private level;
+    private message;
+    private fields;
+    constructor(recorder: LogRecorder);
+    static create(recorder: LogRecorder, context?: string): Logger;
+    clone(): Logger;
+    send(): void;
+    info(message: string): Logger;
+    warn(message: string): Logger;
+    debug(message: string): Logger;
+    error(message: string, err?: any): Logger;
+    withTimestamp(timestamp: Date | string): Logger;
+    withLevel(level: LogLevel): Logger;
+    withMessage(message: string): Logger;
+    withFields(fields: LogFields): Logger;
+    withField(key: string, value: string | number | boolean | Date): Logger;
+    withServiceName(serviceName: string): Logger;
+    withNodeName(nodeName: string): Logger;
+    withVersion(version: string): Logger;
+    withClientType(clientType: ClientType): Logger;
+    withClientServiceName(serviceName: string): Logger;
+    withClientNodeName(nodeName: string): Logger;
+    withClientVersion(version: string): Logger;
+    withTopic(topic: string): Logger;
+    withSubtopic(subtopic: string): Logger;
+    withName(name: string): Logger;
+    withContext(context: string): Logger;
+    withUsingJwt(usingJwt: boolean): Logger;
+    withUsingPassHash(usingPassHash: boolean): Logger;
+    withUserId(userId: string): Logger;
+    withEmail(email: string): Logger;
+    withUrl(url: string): Logger;
+    withSessionRef(sessionRef: string): Logger;
+    withContentKind(kind: string): Logger;
+    withContentRef(ref: string): Logger;
+    withCount(count: number): Logger;
+    withDurationMillis(duration: number): Logger;
+    withDocVersion(version: number): Logger;
+    withWordCount(count: number): Logger;
+    withBucket(bucket: string): Logger;
+    withFileName(fileName: string): Logger;
+    withFileSize(size: number): Logger;
+    withRequestBody(body: any): Logger;
+    clearParams(): Logger;
+    withParams(params: any): Logger;
+    withChangingData(originalData: any, transformedData: any): Logger;
+    withOriginalData(data: any): Logger;
+    withTransformedData(data: any): Logger;
+    withIgnoreConflict(ignoreConflict: boolean): Logger;
+    withError(err: any): Logger;
+    private static ensureStringified;
+    private static enforceFieldType;
+    private static makeTypeErrorMessage;
+}
+export interface LogFields {
+    service_name?: string;
+    node_name?: string;
+    version?: string;
+    client_type?: ClientType;
+    client_service_name?: string;
+    client_node_name?: string;
+    client_version?: string;
+    context?: string;
+    name?: string;
+    topic?: string;
+    subtopic?: string;
+    using_jwt?: boolean;
+    using_pass_hash?: boolean;
+    user_id?: string;
+    email?: string;
+    url?: string;
+    session_ref?: string;
+    content_kind?: string;
+    content_ref?: string;
+    doc_version?: number;
+    word_count?: number;
+    bucket?: string;
+    file_name?: string;
+    file_size?: number;
+    count?: number;
+    duration_millis?: number;
+    request_body?: string;
+    params?: string;
+    original_data?: string;
+    transformed_data?: string;
+    ignore_conflict?: boolean;
+    error_body?: string;
+    [key: string]: string | number | boolean;
+}