@shaxpir/duiduidui-models 1.0.1 → 1.2.0

package/lib/util/Dispatch.ts

@@ -1,92 +0,0 @@
-export type DispatchTopic = string;
-export type DispatchCallback = (topic:string, details?:any) => void;
-
-export interface DispatchMessage {
-  topic:DispatchTopic;
-  details?:any;
-}
-
-export class Dispatch {
-
-  private static debug:boolean = false;
-
-  private static readonly callbacksByTopic:Map<DispatchTopic, DispatchCallback[]> = new Map();
-
-  public static setDebug(value:boolean):void {
-    Dispatch.debug = value;
-  }
-
-  public static subscribe(
-    topic:string,
-    callback:DispatchCallback
-  ):void {
-    let topicCallbacks:DispatchCallback[] = [];
-    if (Dispatch.callbacksByTopic.has(topic)) {
-      topicCallbacks = Dispatch.callbacksByTopic.get(topic);
-    } else {
-      Dispatch.callbacksByTopic.set(topic, topicCallbacks);
-    }
-    topicCallbacks.push(callback);
-  }
-
-  public static unsubscribe(
-    topic:DispatchTopic,
-    callback:DispatchCallback
-  ) {
-    if (Dispatch.callbacksByTopic.has(topic)) {
-      let topicCallbacks:DispatchCallback[] = [];
-      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.
-  public static async publish(topic:DispatchTopic, details?:any):Promise<void> {
-    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).
-  public static async sequence(messages:DispatchMessage[]):Promise<void> {
-    for (let i = 0, len = messages.length; i < len; i++) {
-      let message:DispatchMessage = messages[i];
-      await Dispatch.publish(message.topic, message.details);
-    }
-  }
-}

package/lib/util/NumberFormat.ts

@@ -1,194 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,131 +0,0 @@
-
-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;
-  }
-
-}