@shaxpir/duiduidui-models 1.0.0

package/lib/util/NumberFormat.ts

@@ -0,0 +1,194 @@
+export class NumberFormat {
+
+  private static readonly ORDINAL_REGEX:RegExp = /^\d*(?:1st|2nd|3rd|[04-9]th|1[23]th)$/i;
+
+  private static readonly NUMERIC_WORD_SEQUENCE:RegExp = /(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)(?:(?:\s*(?:\sand\s+|-\s*)(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen|(?:twen|thir|for|fif|six|seven|eigh|nine)ty|[mb]illion|thousand|hundred)))*/i;
+  private static readonly ROMAN_NUMERALS:RegExp = /\b[MDCLXVI]+\b/i;
+
+  public static commas(value:number, keepFractions:boolean):string {
+    if (!Number.isFinite(value)) {
+      return "0"; //  We never want to show "NaN" or "Infinity" in shaxpir. Zero is always preferable.
+    }
+    let original:number = value;
+    let isNegative:boolean = value < 0;
+    let absValue:number = Math.abs(value);
+    let floorValue:number = Math.floor(absValue);
+    let v:number = floorValue;
+    let formatted:string = "";
+    if (v === 0) {
+      formatted = "0";
+    }
+    while (v > 0) {
+      if (formatted.length > 0) {
+        formatted = "," + formatted;
+      }
+      let remainder:number = (v % 1000);
+      v = Math.floor(v / 1000);
+      if (v > 0) {
+        if (remainder < 10) {
+          formatted = "00" + remainder + formatted;
+        } else if (remainder < 100) {
+          formatted = "0" + remainder + formatted;
+        } else {
+          formatted = remainder + formatted;
+        }
+      } else {
+        formatted = remainder + formatted;
+      }
+    }
+    if (keepFractions && absValue !== floorValue) {
+      formatted += "." + original.toString().split('.')[1];
+    }
+    if (isNegative) {
+      formatted = "-" + formatted;
+    }
+    return formatted;
+  }
+
+  public static ordinal(value:number):string {
+    if (value == 1 || (value % 10 == 1 && value != 11)) {
+      return "st";
+    } else if (value == 2 || (value % 10 == 2 && value != 12)) {
+      return "nd";
+    } else if (value == 3 || (value % 10 == 3 && value != 13)) {
+      return "rd";
+    } else {
+      return "th";
+    }
+  }
+
+  public static isOrdinal(text:string):boolean {
+    return NumberFormat.ORDINAL_REGEX.test(text);
+  }
+
+  public static dollarsFromCents(value:number):string {
+    let dollars:number = Math.floor(value / 100);
+    let cents:number = value - (dollars * 100);
+    if (cents === 0) {
+      return "$" + dollars + ".00";
+    } else if (cents < 10) {
+      return "$" + dollars + ".0" + cents;
+    } else {
+      return "$" + dollars + "." + cents;
+    }
+  }
+
+  public static percent(value:number, fractionDigits:number = 0):string {
+    let numbers:string = NumberFormat.commas(value * 100, fractionDigits > 0);
+    if (fractionDigits > 0 && value !== 0) {
+      let indexOfDecimal:number = numbers.lastIndexOf(".");
+      if (indexOfDecimal >= 0) {
+        let numsBeforeDecimal:string = numbers.substring(0, indexOfDecimal);
+        let numsAfterDecimal:string = numbers.substring(indexOfDecimal + 1);
+        if (numsAfterDecimal.length > fractionDigits) {
+          numbers = numsBeforeDecimal + "." + numsAfterDecimal.substring(0, fractionDigits);
+        }
+      }
+    }
+    return numbers + "%";
+  }
+
+  public static text(value:number):string {
+    let isNegative:boolean = value < 0;
+    value = Math.abs(Math.round(value));
+    let asText:string;
+    if (value == 0) {
+      asText = "zero";
+    } else if (value == 1) {
+      asText = "one";
+    } else if (value == 2) {
+      asText = "two";
+    } else if (value == 3) {
+      asText = "three";
+    } else if (value == 4) {
+      asText = "four";
+    } else if (value == 5) {
+      asText = "five";
+    } else if (value == 6) {
+      asText = "six";
+    } else if (value == 7) {
+      asText = "seven";
+    } else if (value == 8) {
+      asText = "eight";
+    } else if (value == 9) {
+      asText = "nine";
+    } else if (value == 10) {
+      asText = "ten";
+    } else if (value == 11) {
+      asText = "eleven";
+    } else if (value == 12) {
+      asText = "twelve";
+    } else if (value == 13) {
+      asText = "thirteen";
+    } else if (value == 14) {
+      asText = "fourteen";
+    } else if (value == 15) {
+      asText = "fifteen";
+    } else if (value == 16) {
+      asText = "sixteen";
+    } else if (value == 17) {
+      asText = "seventeen";
+    } else if (value == 18) {
+      asText = "eighteen";
+    } else if (value == 19) {
+      asText = "nineteen";
+    } else if (value >= 20 && value <= 99) {
+      let tensPlace = Math.floor(value / 10);
+      let onesPlace = value % 10;
+      if (tensPlace == 2) {
+        asText = "twenty";
+      } else if (tensPlace == 3) {
+        asText = "thirty";
+      } else if (tensPlace == 4) {
+        asText = "forty";
+      } else if (tensPlace == 5) {
+        asText = "fifty";
+      } else if (tensPlace == 6) {
+        asText = "sixty";
+      } else if (tensPlace == 7) {
+        asText = "seventy";
+      } else if (tensPlace == 8) {
+        asText = "eighty";
+      } else if (tensPlace == 9) {
+        asText = "ninety";
+      }
+      if (onesPlace !== 0) {
+        asText += "-" + NumberFormat.text(onesPlace);
+      }
+    } else if (value >= 100 && value <= 999) {
+      let hundredsPlace = Math.floor(value / 100);
+      asText = NumberFormat.text(hundredsPlace) + " hundred " + NumberFormat.text(value - (hundredsPlace * 100));
+    } else if (value >= 1000 && value <= 9999) {
+      let thousandsPlace = Math.floor(value / 1000);
+      asText = NumberFormat.text(thousandsPlace) + " thousand " + NumberFormat.text(value - (thousandsPlace * 1000));
+    }
+    if (isNegative) {
+      asText = "minus " + asText;
+    }
+    return asText;
+  }
+
+  public static findNumericWordSequence(text:string):string {
+    let result = NumberFormat.NUMERIC_WORD_SEQUENCE.exec(text);
+    if (result !== null) {
+      return result[0];
+    }
+    return null;
+  }
+
+  public static findRomanNumerals(text:string):string {
+    let result = NumberFormat.ROMAN_NUMERALS.exec(text);
+    if (result !== null) {
+      return result[0];
+    }
+    return null;
+  }
+
+  public static asHex(value:number, padToLength:number = 1):string {
+    let hex:string = Math.floor(value).toString(16);
+    while (hex.length < padToLength) {
+      hex = "0" + hex;
+    }
+    return hex;
+  }
+}

package/lib/util/Struct.ts

@@ -0,0 +1,14 @@
+import rfdc = require('rfdc');
+import isEqual = require('fast-deep-equal');
+const cloneDeep = rfdc();
+
+export class Struct {
+
+  public static clone(value:any):any {
+    return cloneDeep(value);
+  }
+
+  public static equals(a:any, b:any):boolean {
+    return isEqual(a, b);
+  }
+}

package/lib/util/Tuples.ts

@@ -0,0 +1,131 @@
+
+import { JsonPath, PathVal } from "../models/markup/Operation";
+import { Struct } from "./Struct";
+
+export class Tuples {
+
+  public static of(value:any):PathVal[] {
+    let tuples:PathVal[] = [];
+    if (Array.isArray(value)) {
+        Tuples.collectFromArray(tuples, [], value);
+    } else if (value !== null) {
+      const type = typeof(value);
+      if (type === "object") {
+        Tuples.collectFromObject(tuples, [], value);
+      }
+    }
+    return Tuples.sort(tuples);
+  }
+
+  public static stringifyPath(prefix:string, path:JsonPath):string {
+    if (prefix == null || prefix.trim() == "") {
+      prefix = "$";
+    }
+    if (!prefix.startsWith("$")) {
+      prefix = "$" + prefix;
+    }
+    let str = prefix;
+    for (let i = 0; i < path.length; i++) {
+      let pathItem = path[i];
+      if (typeof(pathItem) === 'string') {
+        str += '.' + pathItem;
+      } else {
+        str += '[' + pathItem + ']';
+      }
+    }
+    return str;
+  }
+
+  private static collectFromArray(tuples:PathVal[], path:JsonPath, array:any[]):void {
+    for (let i = 0; i < array.length; i++) {
+      path.push(i);
+      let item = array[i];
+      Tuples.collectTuplesAtPath(tuples, path, item);
+      path.pop();
+    }
+  }
+
+  private static collectFromObject(tuples:PathVal[], path:JsonPath, object:any):void {
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (object.hasOwnProperty(key)) {
+        path.push(key);
+        let item = object[key];
+        Tuples.collectTuplesAtPath(tuples, path, item);
+        path.pop();
+      }
+    }
+  }
+
+  private static collectTuplesAtPath(tuples:PathVal[], path:JsonPath, item:any):void {
+    if (Struct.equals(item, {}) || Struct.equals(item, [])) {
+        tuples.push({ path : Struct.clone(path) as JsonPath, val : item });
+    } else if (Array.isArray(item)) {
+        Tuples.collectFromArray(tuples, path, item);
+    } else {
+      const type = typeof(item);
+      if (
+        item === null ||
+        type === "string" ||
+        type === "number" ||
+        type === "boolean"
+      ) {
+        tuples.push({ path : Struct.clone(path) as JsonPath, val : item });
+      } else if (type === "function" || type == "symbol" || type == "bigint" || type === "undefined") {
+        throw new Error(`can't create tuple from '${type}' item at path: ${JSON.stringify(path)}`);
+      } else {
+        Tuples.collectFromObject(tuples, path, item);
+      }
+    }
+  }
+
+  private static sort(tuples:PathVal[]):PathVal[] {
+    // NOTE: tuples are sorted ONLY according to their PATH. The val is never considered. This is
+    // because we assume there can never be two identical paths anyhow, in a valid JSON tuple array.
+    tuples.sort((a:PathVal, b:PathVal) =>  {
+      const aPath = a.path;
+      const bPath = b.path;
+      const aPathLength = aPath.length;
+      const bPathLength = bPath.length;
+      let length = Math.min(aPathLength, bPathLength);
+      for (let i = 0; i < length; i++) {
+        const aPathElement = aPath[i];
+        const bPathElement = bPath[i];
+        const aPathElementType = typeof(aPathElement);
+        const bPathElementType = typeof(bPathElement);
+        let comparison = 0;
+        if (aPathElementType === "string" && bPathElementType === "string") {
+          const aString = aPathElement as string;
+          const bString = bPathElement as string;
+          comparison = aString.localeCompare(bString);
+        } else if (aPathElementType === "number" && bPathElementType === "number") {
+          const aNumber = aPathElement as number;
+          const bNumber = bPathElement as number;
+          if (aNumber < bNumber) {
+            comparison = -1;
+          } else if (aNumber > bNumber) {
+            comparison = 1;
+          }
+        } else if (aPathElementType === "string" && bPathElementType === "number") {
+          comparison = -1;
+        } else if (aPathElementType === "number" && bPathElementType === "string") {
+          comparison = 1;
+        }
+        if (comparison !== 0) {
+          return comparison;
+        }
+      }
+      if (aPathLength < bPathLength) {
+        return -1;
+      } else if (aPathLength > bPathLength) {
+        return 1;
+      } else {
+        // If we never do want to incorporate value comparisons into sort order, this is where we'd do it.
+        return 0;
+      }
+    });
+    return tuples;
+  }
+
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@shaxpir/duiduidui-models",
+  "version": "1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shaxpir/duiduidui-models"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "mocha tests",
+    "test:watch": "mocha -w tests"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@shaxpir/quill-delta": "^6.1.1",
+    "@shaxpir/rich-text": "^5.0.2",
+    "@shaxpir/sharedb": "^5.3.0",
+    "dayjs": "1.11.7",
+    "hsluv": "latest",
+    "ot-json1": "1.0.1",
+    "ot-text-unicode": "4.0.0",
+    "fast-array-diff": "1.0.1",
+    "json-diff-ts": "1.2.4",
+    "md5": "2.x",
+    "pluralize": "latest",
+    "reconnecting-websocket": "4.4.0",
+    "fast-deep-equal": "^3.1.3",
+    "rfdc": "^1.1.4"
+  },
+  "devDependencies": {
+    "@types/lodash": "latest",
+    "@types/md5": "^2.1.33",
+    "@types/node": "^18.0.50",
+    "@types/pluralize": "0.0.29",
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0",
+    "tslint": "^5.12.1",
+    "typescript": "latest"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "./dist",
+    "noImplicitAny": true,
+    "alwaysStrict": true,
+    "target": "es2021",
+    "declaration": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports":true,
+    "typeRoots": [
+      "./node_modules/@types"
+    ]
+  },
+  "include": [
+    "./lib/**/*",
+    "decs.d.ts"
+  ],
+  "baseUrl": "types",
+  "typeRoots": [
+    "types"
+  ]
+}

package/tslint.json

@@ -0,0 +1,46 @@
+{
+  "extends": "tslint:recommended",
+  "rules": {
+      "eofline": false,
+      "interface-name": false,
+      "max-classes-per-file": false,
+      "max-line-length": {
+          "options": [120]
+      },
+      "member-access": true,
+      "member-ordering": false,
+      "new-parens": true,
+      "no-arg": true,
+      "no-bitwise": true,
+      "no-conditional-assignment": true,
+      "no-consecutive-blank-lines": false,
+      "no-console": {
+          "severity": "warning",
+          "options": ["debug", "info", "log", "time", "timeEnd", "trace"]
+      },
+      "no-unused-variable": true,
+      "object-literal-key-quotes": false,
+      "object-literal-shorthand": false,
+      "object-literal-sort-keys": false,
+      "only-arrow-functions": false,
+      "prefer-const": false,
+      "prefer-for-of": false,
+      "quotemark": false,
+      "radix": false,
+      "trailing-comma": false,
+      "typedef": [true, "call-signature", "parameter"],
+      "typedef-whitespace": [true, {}, {
+        "call-signature": "nospace", 
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }],
+      "variable-name": false,
+      "whitespace": false
+  },
+  "jsRules": {
+      "max-line-length": {
+          "options": [120]
+      }
+  }
+}