@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Stub.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stubs = void 0;
+const pluralize_1 = __importDefault(require("pluralize"));
+const Struct_1 = require("../../util/Struct");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+class Stubs {
+    static idFromStub(stub) {
+        let id = null;
+        if (typeof (stub) === "string") {
+            // The array entry is a bare string... either a locator or an ID.
+            id = Content_1.Content.parseContentRef(stub).id;
+        }
+        else if (stub.hasOwnProperty("id")) {
+            id = stub.id;
+        }
+        else if (stub.hasOwnProperty("ref")) {
+            id = Content_1.Content.parseContentRef(stub.ref).id;
+        }
+        return id;
+    }
+    static refFromStub(stub) {
+        let ref = null;
+        if (typeof (stub) === "string") {
+            ref = stub;
+        }
+        else if (stub.hasOwnProperty("ref")) {
+            ref = stub.ref;
+        }
+        else if (stub.hasOwnProperty("id")) {
+            ref = stub.id;
+        }
+        return ref;
+    }
+    static unflatten(stubs) {
+        const nodesById = new Map();
+        const unflattened = [];
+        for (let i = 0, len = stubs.length; i < len; i++) {
+            const stub = Struct_1.Struct.clone(stubs[i]);
+            const id = Stubs.idFromStub(stub);
+            nodesById.set(id, stub);
+            if (stub.parent && nodesById.has(stub.parent)) {
+                const parentNode = nodesById.get(stub.parent);
+                if (!parentNode.hasOwnProperty("children")) {
+                    parentNode.children = [];
+                }
+                parentNode.children.push(stub);
+            }
+            else {
+                unflattened.push(stub);
+            }
+        }
+        return unflattened;
+    }
+    static isFolderStub(stub) {
+        return stub && stub.hasOwnProperty('kind') && stub.kind == ContentKind_1.ContentKind.FOLDER;
+    }
+    static isContentStub(stub) {
+        return stub && stub.hasOwnProperty('ref');
+    }
+    // Given an array of fragment stubs (like you'd find in 'book.payload.manuscript',
+    // 'book.payload.notebook', or 'book.payload.ideas'), this function adds the
+    // designated stub to the array at the correct index. This is based in part on
+    // whether a fragment is already 'active' (selected by the user in the workspace
+    // tree) and whether the default insertion point is at the beginning or end of
+    // the array. When the correct insertion point has been found the function
+    // automatically injects the correct tree-parent ID into the stub.
+    static insertStubAtActivePoint(stub, stubArrayView, category, activeId, defaultAtBeginning) {
+        // Build a parentage map of all the stubs in the array.
+        const parentage = new Map();
+        const indexesById = new Map();
+        // Try to find a folder whose label matches the pluralization of the category for this stub.
+        // For example, if the stub has a category of "character", then a matching folder would be
+        // named "CHARACTERS" or "Characters". If we find such a folder, then the new stub will be
+        // added within the matching folder's hierarchy.
+        let categoryFolderStubIdx = -1;
+        if (category !== null) {
+            const singularCategory = pluralize_1.default.singular(category.toLowerCase());
+            for (let i = 0, len = stubArrayView.length; i < len; i++) {
+                const currentStub = stubArrayView.get(i);
+                const stubId = Stubs.idFromStub(currentStub);
+                indexesById.set(stubId, i);
+                if (currentStub.parent) {
+                    parentage.set(stubId, currentStub.parent);
+                }
+                if (Stubs.isFolderStub(currentStub)) {
+                    const folderLabel = currentStub.label.toLowerCase();
+                    const singularLabel = pluralize_1.default.singular(folderLabel);
+                    if (singularLabel === singularCategory) {
+                        categoryFolderStubIdx = i;
+                    }
+                }
+            }
+        }
+        // Find the active ID (i.e., whatever is currently selected in the menu) in the stub array
+        let activeIdx = stubArrayView.firstIndexWhere(stub => Stubs.idFromStub(stub) === activeId);
+        // If there isn't an active ID (because nothing is currently selected in the menu), or if
+        // the active ID doesn't seem to be within this particular stub array (manuscript vs notebook),
+        // then treat any category folder we might have found ("Characters" or "Themes", etc) as the
+        // as an active ID.
+        if (activeIdx === -1) {
+            activeIdx = categoryFolderStubIdx;
+        }
+        else if (categoryFolderStubIdx !== -1) {
+            // If the active stub and the category folder stub both exist, then we need to figure out
+            // which of them takes priority. Matching a category folder is more important, so generally,
+            // we will just use the category folder. But if the active index is WITHIN the category
+            // folder, then we'll use the active ID instead.
+            let activeIdIsWithinCategoryFolder = false;
+            let currentStub = stubArrayView.get(activeIdx);
+            while (currentStub) {
+                const currentStubId = Stubs.idFromStub(currentStub);
+                if (parentage.has(currentStubId)) {
+                    const parentId = parentage.get(currentStubId);
+                    if (indexesById.has(parentId)) {
+                        const parentStubIndex = indexesById.get(parentId);
+                        if (parentStubIndex === categoryFolderStubIdx) {
+                            activeIdIsWithinCategoryFolder = true;
+                            break;
+                        }
+                        currentStub = stubArrayView.get(parentStubIndex);
+                    }
+                    else {
+                        // NOTE: It should be impossible to get here, because we've already built a map of all the
+                        // stubs in the array, and we've already checked that the parentage map contains the parent ID.
+                        throw new Error(`Parent ID ${parentId} not found in stub array`);
+                    }
+                }
+                else {
+                    currentStub = undefined;
+                }
+            }
+            if (!activeIdIsWithinCategoryFolder) {
+                activeIdx = categoryFolderStubIdx;
+            }
+        }
+        // Insert the new stub into the array at the index of the active stub (which
+        // may have been adjusted above to point to the category folder index).
+        let idx;
+        if (activeIdx === -1) {
+            // Couldn't find the active ID in the array of stubs. Add the stub at either
+            // the beginning or end of the array, depending on the designated default.
+            if (defaultAtBeginning) {
+                stubArrayView.unshift(stub);
+                idx = 0;
+            }
+            else {
+                idx = stubArrayView.length;
+                stubArrayView.push(stub);
+            }
+        }
+        else {
+            // Find the stub at the active index. If it's a folder, then use it as the parent of the new stub. Otherwise,
+            // if the stub at the active index has a parent, then the new stub should assume the same parent as its sibling.
+            const activeStub = stubArrayView.get(activeIdx);
+            if (Stubs.isFolderStub(activeStub)) {
+                const folderStub = activeStub;
+                stub.parent = folderStub.id;
+            }
+            else if (activeStub.parent) {
+                stub.parent = activeStub.parent;
+            }
+            // Insert the new stub immediately after the active stub.
+            idx = activeIdx + 1;
+            if (idx >= stubArrayView.length) {
+                stubArrayView.push(stub);
+            }
+            else {
+                stubArrayView.insert(idx, stub);
+            }
+        }
+        return idx;
+    }
+}
+exports.Stubs = Stubs;

package/dist/models/content/Time.d.ts

@@ -0,0 +1,56 @@
+import dayjs from 'dayjs';
+declare enum CompactDateTimeBrand {
+}
+declare 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 declare class MultiClock {
+    static utcNow(): MultiTime;
+    static now(): MultiTime;
+}
+export declare class Time {
+    static readonly DATETIME_FORMAT_LEGACY: string;
+    static readonly DATE_FORMAT: string;
+    static readonly DATETIME_FORMAT_COMPACT: string;
+    static readonly DATE_NO_YEAR: string;
+    static readonly DATE_BEAUTIFIED: string;
+    static readonly DATE_FULLY_BEAUTIFIED: string;
+    static readonly YEAR_ONLY: string;
+    static asCompactDateTime(text: string): CompactDateTime;
+    static asCompactDate(text: string): CompactDate | null;
+    static isDateBefore(a: CompactDate, b: CompactDate): boolean;
+    static isDateAfter(a: CompactDate, b: CompactDate): boolean;
+    static compareDate(a: CompactDate, b: CompactDate): number;
+    static isDateTimeBefore(a: CompactDateTime, b: CompactDateTime): boolean;
+    static isDateTimeAfter(a: CompactDateTime, b: CompactDateTime): boolean;
+    static compareDateTime(a: CompactDateTime, b: CompactDateTime): number;
+    static sortByUtcTime(array: MultiTime[]): MultiTime[];
+    static dateFrom(timestamp: CompactDateTime): CompactDate;
+    static datesBetween(minDate: CompactDate, maxDate: CompactDate): CompactDate[];
+    static plus(timestamp: CompactDateTime, amount: number, units: dayjs.ManipulateType): CompactDateTime;
+    static todayLocal(): CompactDate;
+    static todayUtc(): CompactDate;
+    static startOfMonth(date: CompactDate): CompactDate;
+    static local(utc?: CompactDateTime): CompactDateTime;
+    static utcFromEpochSeconds(seconds: number): CompactDateTime;
+    static utc(local?: CompactDateTime): CompactDateTime;
+    static format(timestamp: CompactDateTime, pattern: string, isLocal: boolean): CompactDateTime;
+    static formatFromDate(date: Date, pattern: string): string;
+    static beautify(timestamp: CompactDateTime, isLocal?: boolean, amount?: number, units?: string): string;
+    static absDiffMinutes(a: CompactDateTime, b: CompactDateTime): number;
+    static elapsed(timestamp: CompactDateTime, isLocal: boolean): string;
+    static timeUntil(utcTime: CompactDateTime, units: dayjs.UnitType): number;
+    static timeSince(utcTime: CompactDateTime, units: dayjs.UnitType): number;
+    static currentYear(): string;
+    static humanizedDatePacific(epochSeconds: number): string;
+    static humanizedTimePacific(epochSeconds: number): string;
+}
+export {};

package/dist/models/content/Time.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = exports.MultiClock = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+const dayOfYear_1 = __importDefault(require("dayjs/plugin/dayOfYear"));
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+dayjs_1.default.extend(dayOfYear_1.default);
+var CompactDateTimeBrand;
+(function (CompactDateTimeBrand) {
+})(CompactDateTimeBrand || (CompactDateTimeBrand = {}));
+var CompactDateBrand;
+(function (CompactDateBrand) {
+})(CompactDateBrand || (CompactDateBrand = {}));
+class MultiClock {
+    static utcNow() {
+        const localtime = Time.local();
+        const utcTime = Time.utc(localtime);
+        return {
+            local_time: utcTime,
+            utc_time: utcTime
+        };
+    }
+    static now() {
+        const localtime = Time.local();
+        return {
+            local_time: localtime,
+            utc_time: Time.utc(localtime)
+        };
+    }
+}
+exports.MultiClock = MultiClock;
+class Time {
+    static asCompactDateTime(text) {
+        // A compact datetime is always 17 digits long and starts with '20'
+        if (text.startsWith("20") && /^\d{17}$/.test(text)) {
+            return text;
+        }
+        return null;
+    }
+    static asCompactDate(text) {
+        // A compact date is always 8 digits long and starts with '20'
+        if (text.startsWith("20") && /^\d{8}$/.test(text)) {
+            return text;
+        }
+        return null;
+    }
+    static isDateBefore(a, b) {
+        return Time.compareDate(a, b) < 0;
+    }
+    static isDateAfter(a, b) {
+        return Time.compareDate(a, b) > 0;
+    }
+    static compareDate(a, b) {
+        if (a == null && b == null) {
+            return 0;
+        }
+        else if (a == null) {
+            return -1;
+        }
+        else if (b == null) {
+            return 1;
+        }
+        return a.localeCompare(b);
+    }
+    static isDateTimeBefore(a, b) {
+        return Time.compareDateTime(a, b) < 0;
+    }
+    static isDateTimeAfter(a, b) {
+        return Time.compareDateTime(a, b) > 0;
+    }
+    static compareDateTime(a, b) {
+        if (a == null && b == null) {
+            return 0;
+        }
+        else if (a == null) {
+            return -1;
+        }
+        else if (b == null) {
+            return 1;
+        }
+        return a.localeCompare(b);
+    }
+    static sortByUtcTime(array) {
+        return array.sort((a, b) => Time.compareDateTime(a.utc_time, b.utc_time));
+    }
+    static dateFrom(timestamp) {
+        const timestampText = timestamp;
+        if (timestampText.length >= 8 && /^\d{8}.*/.test(timestampText)) {
+            return timestampText.substring(0, 8);
+        }
+        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));
+        }
+    }
+    static datesBetween(minDate, maxDate) {
+        const dates = new Array();
+        let d = minDate;
+        while (d.localeCompare(minDate) >= 0 && d.localeCompare(maxDate) <= 0) {
+            dates.push(d);
+            d = (0, dayjs_1.default)(d, Time.DATE_FORMAT).add(1, 'days').format(Time.DATE_FORMAT);
+        }
+        return dates;
+    }
+    static plus(timestamp, amount, units) {
+        const time = (0, dayjs_1.default)(timestamp, Time.DATETIME_FORMAT_COMPACT);
+        return time.add(amount, units).format(Time.DATETIME_FORMAT_COMPACT);
+    }
+    static todayLocal() {
+        return Time.dateFrom(Time.local());
+    }
+    static todayUtc() {
+        return Time.dateFrom(Time.utc());
+    }
+    static startOfMonth(date) {
+        let text = date;
+        if (text.startsWith("20") && /^\d{8}$/.test(text)) {
+            text = text.substring(0, 6) + "01;";
+        }
+        return text;
+    }
+    static local(utc) {
+        let result;
+        if (typeof (utc) === "undefined") {
+            result = (0, dayjs_1.default)().format(Time.DATETIME_FORMAT_COMPACT);
+        }
+        else {
+            const timestamp = dayjs_1.default.utc(utc, Time.DATETIME_FORMAT_COMPACT)
+                .local();
+            result = timestamp.format(Time.DATETIME_FORMAT_COMPACT);
+        }
+        return result;
+    }
+    // TODO: Should this actually be called localFromEpochSeconds? Passing zero
+    // returns timestamp that is local-timezone hours offset from UTC epoch time.
+    static utcFromEpochSeconds(seconds) {
+        return dayjs_1.default.unix(seconds).utc().format(Time.DATETIME_FORMAT_COMPACT);
+    }
+    static utc(local) {
+        let result;
+        if (typeof (local) === "undefined") {
+            result = dayjs_1.default.utc().format(Time.DATETIME_FORMAT_COMPACT);
+        }
+        else {
+            const timestamp = (0, dayjs_1.default)(local, Time.DATETIME_FORMAT_COMPACT)
+                .utc();
+            result = timestamp.format(Time.DATETIME_FORMAT_COMPACT);
+        }
+        return result;
+    }
+    static format(timestamp, pattern, isLocal) {
+        let time = null;
+        if (isLocal) {
+            time = (0, dayjs_1.default)(timestamp, Time.DATETIME_FORMAT_COMPACT);
+        }
+        else {
+            time = dayjs_1.default.utc(timestamp, Time.DATETIME_FORMAT_COMPACT)
+                .local();
+        }
+        return time.format(pattern);
+    }
+    static formatFromDate(date, pattern) {
+        const time = (0, dayjs_1.default)(date);
+        return time.format(pattern);
+    }
+    static beautify(timestamp, isLocal = false, amount, units) {
+        const now = (0, dayjs_1.default)();
+        let time = null;
+        if (isLocal) {
+            time = (0, dayjs_1.default)(timestamp, Time.DATETIME_FORMAT_COMPACT);
+        }
+        else {
+            time = dayjs_1.default.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 = "", timePart = "";
+        const timeDayOfYear = time.dayOfYear();
+        const nowDayOfYear = now.dayOfYear();
+        const timeYear = time.year();
+        const nowYear = 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;
+        }
+    }
+    static absDiffMinutes(a, b) {
+        const aMoment = (0, dayjs_1.default)(a, Time.DATETIME_FORMAT_COMPACT);
+        const bMoment = (0, dayjs_1.default)(b, Time.DATETIME_FORMAT_COMPACT);
+        return Math.abs(aMoment.diff(bMoment, 'minutes', true));
+    }
+    static elapsed(timestamp, isLocal) {
+        let time = null;
+        if (isLocal) {
+            time = (0, dayjs_1.default)(timestamp, Time.DATETIME_FORMAT_COMPACT);
+        }
+        else {
+            time = dayjs_1.default.utc(timestamp, Time.DATETIME_FORMAT_COMPACT)
+                .local();
+        }
+        const difference = (0, dayjs_1.default)().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);
+        }
+    }
+    static timeUntil(utcTime, units) {
+        return -Time.timeSince(utcTime, units);
+    }
+    static timeSince(utcTime, units) {
+        const then = dayjs_1.default.utc(utcTime, Time.DATETIME_FORMAT_COMPACT);
+        const now = (0, dayjs_1.default)().utc();
+        return now.diff(then, units, true);
+    }
+    static currentYear() {
+        return (0, dayjs_1.default)().format(Time.YEAR_ONLY);
+    }
+    static humanizedDatePacific(epochSeconds) {
+        return dayjs_1.default.unix(epochSeconds).tz("America/Los_Angeles").format("MMMM D, YYYY");
+    }
+    // TODO: Should this actually expect seconds instead of milliseconds?
+    static humanizedTimePacific(epochSeconds) {
+        return (0, dayjs_1.default)(epochSeconds).tz("America/Los_Angeles").format("h:mm:ss a") + " (Pacific)";
+    }
+}
+exports.Time = Time;
+Time.DATETIME_FORMAT_LEGACY = "YYYY-MM-DDTHH:mm:ss.SSSZ";
+Time.DATE_FORMAT = "YYYYMMDD";
+Time.DATETIME_FORMAT_COMPACT = "YYYYMMDDHHmmssSSS";
+Time.DATE_NO_YEAR = "MMMM D";
+Time.DATE_BEAUTIFIED = "MMMM D, YYYY";
+Time.DATE_FULLY_BEAUTIFIED = "dddd, MMMM D, YYYY";
+Time.YEAR_ONLY = "YYYY";

package/dist/models/content/User.d.ts

@@ -0,0 +1,36 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Content, ContentId, ContentMeta } from "./Content";
+import { 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 declare class ModernUser extends Content {
+    static readonly MIN_PASSWORD_LENGTH: number;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): UserPayload;
+    static create(userId: ContentId, payload: UserPayload, createdAt?: MultiTime): ModernUser;
+    get email(): string;
+    setEmail(value: string): void;
+    get forcePasswordReset(): boolean;
+    setForcePasswordReset(value: boolean): void;
+    get passMd5SaltMd5(): string;
+    setPassMd5SaltMd5(value: string): void;
+    get salt(): string;
+    hasValidPassword(password: string): boolean;
+    hasValidPassMd5(passMd5: string): boolean;
+    static makePassMd5SaltMd5(salt: string, password: string): string;
+    static addSaltToPassMd5(salt: string, passMd5: string): string;
+    static makePassMd5(password: string): string;
+    static isValidPassMd5(passMd5: string, userPayload: UserPayload): boolean;
+    static findByEmail(email: string): Promise<ModernUser[]>;
+}

package/dist/models/content/User.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModernUser = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const Operation_1 = require("../markup/Operation");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Time_1 = require("./Time");
+class ModernUser extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        return this.doc.data.payload;
+    }
+    static create(userId, payload, createdAt) {
+        // User creation always happens in UTC time
+        const now = Time_1.MultiClock.utcNow();
+        // If the createdAt time is not provided, use the current time
+        createdAt ??= now;
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: userId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.USER,
+                id: userId,
+                owner: userId,
+                created_at: createdAt,
+                updated_at: now
+            },
+            payload: payload
+        });
+    }
+    get email() {
+        return this.payload.email;
+    }
+    setEmail(value) {
+        if (this.email != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'email'], value);
+            batch.commit();
+        }
+    }
+    get forcePasswordReset() {
+        return this.payload.force_password_reset;
+    }
+    setForcePasswordReset(value) {
+        if (this.forcePasswordReset != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'force_password_reset'], value);
+            batch.commit();
+        }
+    }
+    get passMd5SaltMd5() {
+        return this.payload.pass_md5_salt_md5;
+    }
+    setPassMd5SaltMd5(value) {
+        if (this.passMd5SaltMd5 != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'pass_md5_salt_md5'], value);
+            batch.commit();
+        }
+    }
+    get salt() {
+        return this.payload.salt;
+    }
+    hasValidPassword(password) {
+        const passMd5 = ModernUser.makePassMd5(password);
+        return this.hasValidPassMd5(passMd5);
+    }
+    hasValidPassMd5(passMd5) {
+        return ModernUser.isValidPassMd5(passMd5, this.payload);
+    }
+    static makePassMd5SaltMd5(salt, password) {
+        const passMd5 = ModernUser.makePassMd5(password);
+        return ModernUser.addSaltToPassMd5(salt, passMd5);
+    }
+    static addSaltToPassMd5(salt, passMd5) {
+        return CachingHasher_1.CachingHasher.makeMd5Hash(passMd5 + salt);
+    }
+    static makePassMd5(password) {
+        return CachingHasher_1.CachingHasher.makeMd5Hash(password);
+    }
+    static isValidPassMd5(passMd5, userPayload) {
+        const passMd5SaltMd5 = ModernUser.addSaltToPassMd5(userPayload.salt, passMd5);
+        return passMd5SaltMd5 === userPayload.pass_md5_salt_md5;
+    }
+    static async findByEmail(email) {
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        return shareSync.findAndAcquire(ContentKind_1.ContentKind.USER, { "payload.email": email });
+    }
+}
+exports.ModernUser = ModernUser;
+ModernUser.MIN_PASSWORD_LENGTH = 8;