@shaxpir/duiduidui-models 1.0.0

package/lib/util/Base62.ts

@@ -0,0 +1,47 @@
+export class Base62 {
+
+  public static readonly CHARS:string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  public static encode(value:number, padToLength:number = 1):string {
+    if (value < 0) {
+      throw new Error("number out of range: " + value);
+    }
+    let result:string = "";
+    while (value > 0) {
+      let index:number = value % 62;
+      let digit:string = Base62.CHARS.charAt(index);
+      result = digit + result;
+      value = Math.floor(value / 62);
+    }
+    while (result.length < padToLength) {
+      result = "0" + result;
+    }
+    return result;
+  }
+
+  public static decode(value:string) {
+    let result = 0;
+    for (let i:number = 0, len:number = value.length; i < len; i++) {
+      let c:string = value.charAt(i);
+      result *= 62;
+      result += Base62.CHARS.indexOf(c);
+    }
+    return result;
+  }
+
+  public static fromHexHash(hex:string, length:number):string {
+    // 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;
+  }
+
+}

package/lib/util/CachingHasher.ts

@@ -0,0 +1,38 @@
+import md5 from 'md5';
+import { ContentId } from '../models/content/Content';
+import { Base62 } from './Base62';
+
+export class CachingHasher {
+
+  private static readonly MAX_SIZE:number = 1000;
+
+  private static md5HashLookup:Map<string, string> = new Map<string, string>();
+  private static contentIdLookup:Map<string, ContentId> = new Map<string, ContentId>();
+
+  public static makeMd5Hash(text:string):string {
+    if (CachingHasher.md5HashLookup.size > CachingHasher.MAX_SIZE) {
+      CachingHasher.md5HashLookup.clear();
+    }
+    if (CachingHasher.md5HashLookup.has(text)) {
+      return CachingHasher.md5HashLookup.get(text);
+    } else {
+      const rawHash = md5(text);
+      this.md5HashLookup.set(text, rawHash);
+      return rawHash;
+    }
+  }
+
+  public static makeMd5ContentId(text:string):ContentId {
+    if (CachingHasher.contentIdLookup.size > CachingHasher.MAX_SIZE) {
+      CachingHasher.contentIdLookup.clear();
+    }
+    if (CachingHasher.contentIdLookup.has(text)) {
+      return CachingHasher.contentIdLookup.get(text);
+    } else {
+      const rawHash = md5(text);
+      const asBase62 = Base62.fromHexHash(rawHash, 16) as ContentId;
+      this.contentIdLookup.set(text, asBase62);
+      return asBase62;
+    }
+  }
+}

package/lib/util/Dispatch.ts

@@ -0,0 +1,92 @@
+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/Encryption.ts

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