@shaxpir/duiduidui-models 1.0.0

package/lib/models/content/Time.ts

@@ -0,0 +1,328 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import dayOfYear from 'dayjs/plugin/dayOfYear';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(dayOfYear);
+
+enum CompactDateTimeBrand {}
+enum CompactDateBrand {}
+
+export type CompactDateTime = string & CompactDateTimeBrand;
+export type CompactDate = string & CompactDateBrand;
+
+export interface SingleTime {
+  utc_time:CompactDateTime;
+}
+
+export interface MultiTime {
+  utc_time:CompactDateTime;
+  local_time:CompactDateTime;
+}
+
+export class MultiClock {
+
+  public static utcNow():MultiTime {
+    const localtime:CompactDateTime = Time.local();
+    const utcTime:CompactDateTime = Time.utc(localtime);
+    return {
+      local_time: utcTime,
+      utc_time: utcTime
+    };
+  }
+
+  public static now():MultiTime {
+    const localtime:CompactDateTime = Time.local();
+    return {
+      local_time: localtime,
+      utc_time: Time.utc(localtime)
+    };
+  }
+}
+
+export class Time {
+
+  public static readonly DATETIME_FORMAT_LEGACY:string = "YYYY-MM-DDTHH:mm:ss.SSSZ";
+
+  public static readonly DATE_FORMAT:string = "YYYYMMDD";
+  public static readonly DATETIME_FORMAT_COMPACT:string = "YYYYMMDDHHmmssSSS";
+
+  public static readonly DATE_NO_YEAR:string = "MMMM D";
+  public static readonly DATE_BEAUTIFIED:string = "MMMM D, YYYY";
+  public static readonly DATE_FULLY_BEAUTIFIED:string = "dddd, MMMM D, YYYY";
+
+  public static readonly YEAR_ONLY:string = "YYYY";
+
+  public static asCompactDateTime(text:string):CompactDateTime {
+    // A compact datetime is always 17 digits long and starts with '20'
+    if (text.startsWith("20") && /^\d{17}$/.test(text)) {
+      return text as CompactDateTime;
+    }
+    return null as CompactDateTime;
+  }
+
+  public static asCompactDate(text:string):CompactDate|null {
+    // A compact date is always 8 digits long and starts with '20'
+    if (text.startsWith("20") && /^\d{8}$/.test(text)) {
+      return text as CompactDate;
+    }
+    return null;
+  }
+
+  public static isDateBefore(a:CompactDate, b:CompactDate):boolean {
+    return Time.compareDate(a, b) < 0;
+  }
+
+  public static isDateAfter(a:CompactDate, b:CompactDate):boolean {
+    return Time.compareDate(a, b) > 0;
+  }
+
+  public static compareDate(a:CompactDate, b:CompactDate):number {
+    if (a == null && b == null) {
+      return 0;
+    } else if (a == null) {
+      return -1;
+    } else if (b == null) {
+      return 1;
+    }
+    return (a as string).localeCompare(b as string);
+  }
+
+  public static isDateTimeBefore(a:CompactDateTime, b:CompactDateTime):boolean {
+    return Time.compareDateTime(a, b) < 0;
+  }
+
+  public static isDateTimeAfter(a:CompactDateTime, b:CompactDateTime):boolean {
+    return Time.compareDateTime(a, b) > 0;
+  }
+
+  public static compareDateTime(a:CompactDateTime, b:CompactDateTime):number {
+    if (a == null && b == null) {
+      return 0;
+    } else if (a == null) {
+      return -1;
+    } else if (b == null) {
+      return 1;
+    }
+    return (a as string).localeCompare(b as string);
+  }
+
+  public static sortByUtcTime(array:MultiTime[]):MultiTime[] {
+    return array.sort((a, b) => Time.compareDateTime(a.utc_time, b.utc_time));
+  }
+
+  public static dateFrom(timestamp:CompactDateTime):CompactDate {
+    const timestampText = timestamp as string;
+    if (timestampText.length >= 8 && /^\d{8}.*/.test(timestampText)) {
+      return timestampText.substring(0, 8) as CompactDate;
+    }
+    if (typeof(timestamp) === "string") {
+      throw new Error("can\x27t parse date from malformed timestamp: " + timestamp);
+    } else {
+      throw new Error("can\x27t parse date from malformed timestamp: " + JSON.stringify(timestamp));
+    }
+  }
+
+  public static datesBetween(minDate:CompactDate, maxDate:CompactDate):CompactDate[] {
+    const dates:CompactDate[] = new Array<CompactDate>();
+    let d:string = minDate;
+    while (d.localeCompare(minDate) >= 0 && d.localeCompare(maxDate) <= 0) {
+      dates.push(d as CompactDate);
+      d = dayjs(d, Time.DATE_FORMAT).add(1, 'days').format(Time.DATE_FORMAT) as CompactDate;
+    }
+    return dates;
+  }
+
+  public static plus(timestamp:CompactDateTime, amount:number, units:dayjs.ManipulateType):CompactDateTime {
+    const time = dayjs(timestamp, Time.DATETIME_FORMAT_COMPACT);
+    return time.add(amount, units).format(Time.DATETIME_FORMAT_COMPACT) as CompactDateTime;
+  }
+
+  public static todayLocal():CompactDate {
+    return Time.dateFrom(Time.local());
+  }
+
+  public static todayUtc():CompactDate {
+    return Time.dateFrom(Time.utc());
+  }
+
+  public static startOfMonth(date:CompactDate):CompactDate {
+    let text = date as string;
+    if (text.startsWith("20") && /^\d{8}$/.test(text)) {
+      text = text.substring(0, 6) + "01;"
+    }
+    return text as CompactDate;
+  }
+
+  public static local(utc?:CompactDateTime):CompactDateTime {
+    let result;
+    if (typeof(utc) === "undefined") {
+      result = dayjs().format(Time.DATETIME_FORMAT_COMPACT);
+    } else {
+      const timestamp = dayjs.utc(utc, Time.DATETIME_FORMAT_COMPACT)
+        .local()
+      ;
+      result = timestamp.format(Time.DATETIME_FORMAT_COMPACT);
+    }
+    return result as CompactDateTime;
+  }
+
+  // TODO: Should this actually be called localFromEpochSeconds? Passing zero
+  // returns timestamp that is local-timezone hours offset from UTC epoch time.
+  public static utcFromEpochSeconds(seconds:number):CompactDateTime {
+    return dayjs.unix(seconds).utc().format(Time.DATETIME_FORMAT_COMPACT) as CompactDateTime;
+  }
+
+  public static utc(local?:CompactDateTime):CompactDateTime {
+    let result;
+    if (typeof(local) === "undefined") {
+      result = dayjs.utc().format(Time.DATETIME_FORMAT_COMPACT);
+    } else {
+      const timestamp = dayjs(local, Time.DATETIME_FORMAT_COMPACT)
+        .utc()
+      ;
+      result = timestamp.format(Time.DATETIME_FORMAT_COMPACT);
+    }
+    return result as CompactDateTime;
+  }
+
+  public static format(timestamp:CompactDateTime, pattern:string, isLocal:boolean):CompactDateTime {
+    let time = null;
+    if (isLocal) {
+      time = dayjs(timestamp, Time.DATETIME_FORMAT_COMPACT);
+    } else {
+      time = dayjs.utc(timestamp, Time.DATETIME_FORMAT_COMPACT)
+        .local()
+      ;
+    }
+    return time.format(pattern) as CompactDateTime;
+  }
+
+  public static formatFromDate(date:Date, pattern:string):string {
+    const time = dayjs(date);
+    return time.format(pattern);
+  }
+
+  public static beautify(
+    timestamp:CompactDateTime,
+    isLocal:boolean = false,
+    amount?:number,
+    units?:string
+  ):string {
+    const now:any = dayjs();
+    let time:any = null;
+    if (isLocal) {
+      time = dayjs(timestamp, Time.DATETIME_FORMAT_COMPACT);
+    } else {
+      time = dayjs.utc(timestamp, Time.DATETIME_FORMAT_COMPACT)
+        .local()
+      ;
+    }
+
+    // If the 'num' and 'units' params exist, then use them to manipulate the timestamp
+    if (typeof(amount) === "number" && typeof(units) === "string") {
+      time = time.add(amount, units);
+    }
+
+    let datePart:string = "", timePart:string = "";
+
+    const timeDayOfYear:number = time.dayOfYear();
+    const nowDayOfYear:number = now.dayOfYear();
+    const timeYear:number = time.year();
+    const nowYear:number = now.year();
+    if (nowDayOfYear === timeDayOfYear && nowYear === timeYear) {
+      datePart = "Today";
+    } else if (nowDayOfYear - timeDayOfYear === 1 && nowYear === timeYear) {
+      datePart = "Yesterday";
+    } else if (nowDayOfYear === 1 && timeDayOfYear === 365 && timeYear % 4 !== 0 && nowYear - timeYear === 1) {
+      datePart = "Yesterday";
+    } else if (nowDayOfYear === 1 && timeDayOfYear === 366 && timeYear % 4 === 0 && nowYear - timeYear === 1) {
+      datePart = "Yesterday";
+
+    } else if (timeDayOfYear - nowDayOfYear === 1 && timeYear === nowYear) {
+      datePart = "Tomorrow";
+    } else if (timeDayOfYear === 1 && nowDayOfYear === 365 && nowYear % 4 !== 0 && timeYear - nowYear === 1) {
+      datePart = "Tomorrow";
+    } else if (timeDayOfYear === 1 && nowDayOfYear === 366 && nowYear % 4 === 0 && timeYear - nowYear === 1) {
+      datePart = "Tomorrow";
+
+    } else if (Math.abs(now.diff(time, "days")) <= 30) {
+      datePart = time.format(Time.DATE_FULLY_BEAUTIFIED);
+    } else {
+      datePart = time.format(Time.DATE_BEAUTIFIED);
+    }
+
+    if (Math.abs(now.diff(time, "days")) <= 7) {
+      timePart = time.format("h:mm a");
+      timePart = timePart.replace(" am", "a");
+      timePart = timePart.replace(" pm", "p");
+    }
+
+    if (timePart.length === 0) {
+      return datePart;
+    } else {
+      return datePart + ", " + timePart;
+    }
+  }
+
+  public static absDiffMinutes(a:CompactDateTime, b:CompactDateTime):number {
+    const aMoment = dayjs(a, Time.DATETIME_FORMAT_COMPACT);
+    const bMoment = dayjs(b, Time.DATETIME_FORMAT_COMPACT);
+    return Math.abs(aMoment.diff(bMoment, 'minutes', true));
+  }
+
+  public static elapsed(timestamp:CompactDateTime, isLocal:boolean):string {
+    let time = null;
+    if (isLocal) {
+      time = dayjs(timestamp, Time.DATETIME_FORMAT_COMPACT);
+    } else {
+      time = dayjs.utc(timestamp, Time.DATETIME_FORMAT_COMPACT)
+        .local()
+      ;
+    }
+    const difference = dayjs().diff(time, 'seconds');
+    if (difference < 60) {
+      return difference === 1 ? "1 second ago" : difference + " seconds ago";
+    } else if (difference < 3 * 60) {
+      const minutes = Math.floor(difference / 60);
+      const seconds = Math.floor(difference % 60);
+      const minText = minutes === 1 ? "1 minute" : minutes + " minutes";
+      const secText = seconds === 1 ? "1 second" : seconds + " seconds";
+      return minText + ", " + secText + " ago";
+    } else if (difference < 60 * 60) {
+      const minutes = Math.round(difference / 60);
+      return "about " + minutes + " minutes ago";
+    } else if (difference < 24 * 60 * 60) {
+      const hours = Math.round(difference / (60 * 60));
+      return "about " + hours + " hours ago";
+    } else {
+      return Time.beautify(timestamp, isLocal);
+    }
+  }
+
+  public static timeUntil(utcTime:CompactDateTime, units:dayjs.UnitType):number {
+    return - Time.timeSince(utcTime, units);
+  }
+
+  public static timeSince(utcTime:CompactDateTime, units:dayjs.UnitType):number {
+    const then = dayjs.utc(utcTime, Time.DATETIME_FORMAT_COMPACT);
+    const now = dayjs().utc();
+    return now.diff(then, units, true);
+  }
+
+  public static currentYear():string {
+    return dayjs().format(Time.YEAR_ONLY);
+  }
+
+  public static humanizedDatePacific(epochSeconds:number):string {
+    return dayjs.unix(epochSeconds).tz("America/Los_Angeles").format("MMMM D, YYYY");
+  }
+
+  // TODO: Should this actually expect seconds instead of milliseconds?
+  public static humanizedTimePacific(epochSeconds:number):string {
+    return dayjs(epochSeconds).tz("America/Los_Angeles").format("h:mm:ss a") + " (Pacific)";
+  }
+
+
+}

package/lib/models/content/User.ts

@@ -0,0 +1,130 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { CachingHasher } from '../../util/CachingHasher';
+import { BatchOperation } from '../markup/Operation';
+import { Content, ContentId, ContentMeta } from "./Content";
+import { ContentKind } from './ContentKind';
+import { MultiClock, MultiTime } from "./Time";
+
+export interface UserPayload {
+  email:string;
+  phone:string;
+  force_password_reset:boolean;
+  pass_md5_salt_md5:string;
+  salt:string;
+}
+
+export interface ModernUserBody {
+  meta:ContentMeta;
+  payload:UserPayload;
+}
+
+export class ModernUser extends Content {
+
+  public static readonly MIN_PASSWORD_LENGTH:number = 8;
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():UserPayload {
+    return this.doc.data.payload as UserPayload;
+  }
+
+  public static create(
+    userId:ContentId,
+    payload:UserPayload,
+    createdAt?:MultiTime
+  ):ModernUser {
+    // User creation always happens in UTC time
+    const now = MultiClock.utcNow();
+    // If the createdAt time is not provided, use the current time
+    createdAt ??= now;
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : userId,
+          is_head : true,
+          kind : ContentKind.USER,
+          id : userId,
+          owner : userId,
+          created_at : createdAt,
+          updated_at : now
+        },
+        payload : payload
+      }
+    ) as ModernUser;
+  }
+
+  public get email():string {
+    return this.payload.email;
+  }
+  public setEmail(value:string) {
+    if (this.email != value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'email' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get forcePasswordReset():boolean {
+    return this.payload.force_password_reset;
+  }
+  public setForcePasswordReset(value:boolean) {
+    if (this.forcePasswordReset != value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'force_password_reset' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get passMd5SaltMd5():string {
+    return this.payload.pass_md5_salt_md5;
+  }
+  public setPassMd5SaltMd5(value:string) {
+    if (this.passMd5SaltMd5 != value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'pass_md5_salt_md5' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get salt():string {
+    return this.payload.salt;
+  }
+
+  public hasValidPassword(password:string):boolean {
+    const passMd5 = ModernUser.makePassMd5(password);
+    return this.hasValidPassMd5(passMd5);
+  }
+
+  public hasValidPassMd5(passMd5:string):boolean {
+    return ModernUser.isValidPassMd5(passMd5, this.payload);
+  }
+
+  public static makePassMd5SaltMd5(salt:string, password:string):string {
+    const passMd5 = ModernUser.makePassMd5(password);
+    return ModernUser.addSaltToPassMd5(salt, passMd5);
+  }
+
+  public static addSaltToPassMd5(salt:string, passMd5:string):string {
+    return CachingHasher.makeMd5Hash(passMd5 + salt);
+  }
+
+  public static makePassMd5(password:string):string {
+    return CachingHasher.makeMd5Hash(password);
+  }
+
+  public static isValidPassMd5(passMd5:string, userPayload:UserPayload):boolean {
+    const passMd5SaltMd5 = ModernUser.addSaltToPassMd5(userPayload.salt, passMd5);
+    return passMd5SaltMd5 === userPayload.pass_md5_salt_md5;
+  }
+
+  public static async findByEmail(email:string):Promise<ModernUser[]> {
+    const shareSync = ShareSyncFactory.get();
+    return shareSync.findAndAcquire(
+      ContentKind.USER, { "payload.email" : email }
+    ) as Promise<ModernUser[]>;
+  }
+
+}

package/lib/models/markup/ChangeModel.ts

@@ -0,0 +1,95 @@
+import { Op as DeltaOp } from "@shaxpir/quill-delta";
+import * as Changesets from 'json-diff-ts';
+import { Operation } from "json-diff-ts";
+import { Tuples } from "../../util/Tuples";
+import { Model } from "../content/Model";
+
+export interface ChangeItem {
+  type:Operation;
+  path:string;
+  value?:any;
+  oldValue?:any;
+}
+
+export interface ModelChange {
+  local:boolean;
+  model:Model;
+  items:ChangeItem[];
+  op:DeltaOp[];
+}
+
+export class Changes {
+  public static withPathPrefix(change:ModelChange, prefix:string):boolean {
+    let matchingItems:ChangeItem[] = Changes.havingPathPrefix(change, prefix);
+    return matchingItems.length > 0;
+  }
+  public static havingPathPrefix(change:ModelChange, prefix:string):ChangeItem[] {
+    let matchingItems:ChangeItem[] = [];
+    const items = change.items;
+    for (let i = 0, len = items.length; i < len; i++) {
+      const item = items[i];
+      if (item.path.startsWith(prefix)) {
+        matchingItems.push(item);
+      }
+    }
+    return matchingItems;
+  }
+}
+
+// We have our own ChangeModel logic for performaning a diff between two objects. The main difference
+// between our model and the json-diff implementation is that we care about enumerating the full-path
+// to all modified model data elements, so that various GUI mediators can match against those paths
+// and decide whether or not to re-render a view. So, when a deeply-nested object is added into
+// another deeply nested object, the change-model should include the full path to all new R-Values
+// added in the change, rather than just the path to the root of the new tree branches.
+export class ChangeModel {
+  public static between(before:any, after:any):ChangeItem[] {
+    let changeItems:ChangeItem[] = [];
+    const diff = Changesets.flattenChangeset(
+      Changesets.diff(before, after)
+    );
+    for (let i = 0; i < diff.length; i++) {
+      let diffItem = diff[i];
+      let type:Operation = diffItem.type;
+      let path:string = diffItem.path;
+      let value:any = diffItem.value;
+      let oldValue:any = diffItem.oldValue;
+      let valueType:string = diffItem.valueType;
+      let key:string = diffItem.key;
+      if (valueType === 'Object' || valueType == 'Array') {
+        let tuples = Tuples.of(value);
+        let fullPath = path;
+        if (/^\d+$/.test(key) && !path.endsWith('[' + key + ']')) {
+          fullPath = path + '[' + key + ']';
+        }
+        if (!/^\d+$/.test(key) && !path.endsWith('.' + key)) {
+          fullPath = path + '.' + key;
+        }
+        if (tuples.length == 0) {
+          if (type == 'REMOVE') {
+            changeItems.push({ type : type,  path : fullPath, oldValue : value });
+          } else {
+            changeItems.push({ type : type,  path : fullPath, value : value, oldValue : oldValue });
+          }
+        } else {
+          for (let j = 0; j < tuples.length; j++) {
+            let tuple = tuples[j];
+            let fullTuplePath = Tuples.stringifyPath(fullPath, tuple.path);
+            if (type == 'REMOVE') {
+              changeItems.push({ type : type,  path : fullTuplePath, oldValue : tuple.val });
+            } else {
+              changeItems.push({ type : type,  path : fullTuplePath, value : tuple.val });
+            }
+          }
+        }
+      } else {
+        if (type == 'REMOVE') {
+          changeItems.push({ type : type,  path : path, oldValue : value });
+        } else {
+          changeItems.push({ type : type,  path : path, value : value, oldValue : oldValue });
+        }
+      }
+    }
+    return changeItems;
+  }
+}

package/lib/models/markup/DeltaOps.ts

@@ -0,0 +1,71 @@
+import { AttributeMap, Op as DeltaOp } from "@shaxpir/quill-delta";
+import { Struct } from "../../util/Struct";
+
+export class DeltaOpsModel {
+
+  private static readonly BLOCK_ATTR_KEYS:any = {
+    "align" : true,
+    "blockquote" : true,
+    "header" : true,
+    "indent" : true,
+    "list" : true,
+    "caption" : true,
+  };
+
+  public static splitOnNewlines(ops:DeltaOp[]):DeltaOp[] {
+    let newOps:DeltaOp[] = [];
+    for (let i:number = 0, iLen:number = ops.length; i < iLen; i++) {
+      let op:DeltaOp = ops[i];
+      let text:any = "\n";
+      let embed:AttributeMap = null;
+      let blockAttr:AttributeMap = null;
+      let rangeAttr:AttributeMap = null;
+      if (typeof(op.insert) === "string") {
+        text = op.insert;
+        if (op.hasOwnProperty("attributes")) {
+          for (let key in op.attributes) {
+            let val:any = (op.attributes as any)[key];
+            if (DeltaOpsModel.BLOCK_ATTR_KEYS.hasOwnProperty(key)) {
+              if (blockAttr == null) {
+                blockAttr = {};
+              }
+              (blockAttr as any)[key] = val;
+            } else {
+              if (rangeAttr == null) {
+                rangeAttr = {};
+              }
+              (rangeAttr as any)[key] = val;
+            }
+          }
+
+        }
+      } else if (op.hasOwnProperty("insert")) {
+        embed = Struct.clone(op.insert);
+      }
+      let parts:string[] = text.split(/(\n)/g);
+      let nonEmptyParts:string[] = [];
+      for (let j:number = 0, jLen:number = parts.length; j < jLen; j++) {
+        let part:string = parts[j];
+        if (part.length > 0) {
+          nonEmptyParts.push(part);
+        }
+      }
+      parts = nonEmptyParts;
+      for (let j:number = 0, jLen:number = parts.length, jLast = jLen - 1; j < jLen; j++) {
+        let part:string = parts[j];
+        let newOp:DeltaOp = { "insert" : part, "attributes" : {} };
+        if (embed !== null) {
+          newOp.insert = embed;
+        } else if (part === "\n") {
+          if (j === jLast && blockAttr != null) {
+            newOp.attributes = blockAttr;
+          }
+        } else if (rangeAttr != null) {
+          newOp.attributes = rangeAttr;
+        }
+        newOps.push(newOp);
+      }
+    }
+    return newOps;
+  }
+}