@shaxpir/duiduidui-models 1.0.1 → 1.1.0

package/lib/models/content/Time.ts

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

@@ -1,130 +0,0 @@
-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/content/index.ts

@@ -1,19 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './ArrayView';
-export * from './Billing';
-export * from './Content';
-export * from './ContentKind';
-export * from './DevEnv';
-export * from './Device';
-export * from './DictionaryEntry';
-export * from './GeoLocation';
-export * from './Hanzi';
-export * from './Manifest';
-export * from './Media';
-export * from './Model';
-export * from './Permissions';
-export * from './Phrase';
-export * from './Profile';
-export * from './Time';
-export * from './User';

package/lib/models/markup/DeltaOps.ts

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

package/lib/models/markup/index.ts

@@ -1,6 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './ChangeModel';
-export * from './DeltaOps';
-export * from './Operation';
-export * from './TextEditOps';

package/lib/util/Base62.ts

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

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