@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Manifest.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Manifest = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const Operation_1 = require("../markup/Operation");
+const ContentKind_1 = require("./ContentKind");
+const Model_1 = require("./Model");
+const Time_1 = require("./Time");
+class Manifest extends Model_1.Model {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    static makeManifestId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.MANIFEST);
+    }
+    static create(userId) {
+        const now = Time_1.Time.utc();
+        const manifestId = Manifest.makeManifestId(userId);
+        return ShareSync_1.ShareSyncFactory.get().createManifest({
+            meta: {
+                kind: ContentKind_1.ContentKind.MANIFEST,
+                ref: manifestId,
+                updated_at: {
+                    utc_time: now
+                },
+                owner: userId
+            },
+            payload: {
+                device: {},
+                media: {},
+                profile: {},
+                user: {}
+            }
+        });
+    }
+    get meta() {
+        this.checkDisposed("Manifest.meta");
+        return this.doc.data.meta;
+    }
+    get owner() {
+        this.checkDisposed("Manifest.userId");
+        return this.doc.data.meta.owner;
+    }
+    canUserView(userId) {
+        this.checkDisposed("Manifest.canUserView");
+        return this.doc.data.meta.owner === userId;
+    }
+    doesContentExist(kind, ref) {
+        this.checkDisposed("Manifest.doesContentExist");
+        return this.doc.data &&
+            this.doc.data.payload &&
+            this.doc.data.payload[kind] &&
+            this.doc.data.payload[kind][ref];
+    }
+    getUtcTimeOf(kind, ref) {
+        this.checkDisposed("Manifest.getTimestampOf");
+        if (this.doesContentExist(kind, ref)) {
+            return this.doc.data.payload[kind][ref];
+        }
+        return null;
+    }
+    getAllEntries() {
+        return this.getAllEntriesWhere(() => true);
+    }
+    getAllEntriesWhere(predicate) {
+        const entries = [];
+        if (this.exists() && this.doc.data.payload) {
+            Manifest.forEachEntry(this.doc.data, (entry) => {
+                if (!predicate || predicate(entry)) {
+                    entries.push(entry);
+                }
+            });
+        }
+        return entries;
+    }
+    update(content) {
+        this.checkDisposed("Manifest.update");
+        content.acquire().then(() => {
+            const kind = content.kind;
+            const contentRef = content.ref;
+            const timestamp = content.updatedAt.utc_time;
+            const batch = new Operation_1.BatchOperation(this, content.meta.updated_at);
+            // Update the embedded timestamp of this content item
+            batch.setPathValue(['payload', kind, contentRef], timestamp);
+            batch.commit();
+            content.release();
+        });
+    }
+    static forEachEntry(body, callback) {
+        const kinds = Object.keys(body.payload);
+        for (let i = 0; i < kinds.length; i++) {
+            const kind = kinds[i];
+            const manifestPayload = body.payload[kind];
+            const refs = Object.keys(manifestPayload);
+            for (let j = 0; j < refs.length; j++) {
+                const ref = refs[j];
+                const timestamp = manifestPayload[ref];
+                if (ref && timestamp) {
+                    const entry = {
+                        kind: kind,
+                        ref: ref,
+                        at_utc_time: timestamp
+                    };
+                    callback(entry);
+                }
+                else {
+                    console.error(`manifest with missing ref or timestamp: ${JSON.stringify(body)}`);
+                }
+            }
+        }
+    }
+}
+exports.Manifest = Manifest;

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

@@ -0,0 +1,32 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Content, ContentBody, ContentId, ContentMeta } from './Content';
+export interface MediaDimensions {
+    width: number;
+    height: number;
+}
+export interface MediaCropping extends MediaDimensions {
+    offset_top: number;
+    offset_left: number;
+}
+export interface MediaPayload extends MediaDimensions {
+    extension: string;
+    bytes: number;
+}
+export interface MediaBody extends ContentBody {
+    meta: ContentMeta;
+    payload: MediaPayload;
+}
+export declare class Media extends Content {
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): MediaPayload;
+    static create(userId: ContentId, mediaId: ContentId, payload: MediaPayload): Media;
+    get bytes(): number;
+    get width(): number;
+    get height(): number;
+    get extension(): string;
+    get mediaType(): string;
+    scaleToFit(boxSize: number, cropping: MediaCropping): MediaCropping;
+    static makeDefaultCropping(media: Media): MediaCropping;
+}

package/dist/models/content/Media.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Media = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Time_1 = require("./Time");
+class Media extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Media.payload");
+        return this.doc.data.payload;
+    }
+    static create(userId, mediaId, payload) {
+        const now = Time_1.MultiClock.now();
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: mediaId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.MEDIA,
+                id: mediaId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: payload
+        });
+    }
+    get bytes() {
+        this.checkDisposed("Media.bytes");
+        return this.payload.bytes;
+    }
+    get width() {
+        this.checkDisposed("Media.width");
+        return this.payload.width;
+    }
+    get height() {
+        this.checkDisposed("Media.height");
+        return this.payload.height;
+    }
+    get extension() {
+        this.checkDisposed("Media.extension");
+        return this.payload.extension;
+    }
+    get mediaType() {
+        this.checkDisposed("Media.mediaType");
+        const extension = this.extension;
+        if (extension === "jpg" || extension === "jpeg") {
+            return "image/jpeg";
+        }
+        else if (extension === "png") {
+            return "image/png";
+        }
+        else if (extension === "gif") {
+            return "image/gif";
+        }
+        else if (extension === "svg") {
+            return "image/svg+xml";
+        }
+        else if (extension === "bmp") {
+            return "image/bmp";
+        }
+        return "image/" + extension;
+    }
+    scaleToFit(boxSize, cropping) {
+        this.checkDisposed("Media.scaleToFit");
+        const zoom = boxSize / cropping.width;
+        const scaledWidth = Math.floor(this.width * zoom);
+        const scaledHeight = Math.floor(this.height * zoom);
+        const offsetLeft = -Math.floor(cropping.offset_left * zoom);
+        const offsetTop = -Math.floor(cropping.offset_top * zoom);
+        return {
+            "offset_top": offsetTop,
+            "offset_left": offsetLeft,
+            "width": scaledWidth,
+            "height": scaledHeight
+        };
+    }
+    static makeDefaultCropping(media) {
+        const width = media.width;
+        const height = media.height;
+        const isLandscapeOrSquare = width >= height;
+        const isPortraitOrSquare = height >= width;
+        const croppingOffsetTop = isLandscapeOrSquare ? 0 : Math.floor((height - width) / 2);
+        const croppingOffsetLeft = isPortraitOrSquare ? 0 : Math.floor((width - height) / 2);
+        const croppingWidth = isLandscapeOrSquare ? height : width;
+        const croppingHeight = isPortraitOrSquare ? width : height;
+        return {
+            offset_top: croppingOffsetTop,
+            offset_left: croppingOffsetLeft,
+            width: croppingWidth,
+            height: croppingHeight
+        };
+    }
+}
+exports.Media = Media;

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

@@ -0,0 +1,46 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from "../../repo/ShareSync";
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { CompactDate } from "./Time";
+export declare enum MetricName {
+    WORD_COUNT = "word_count",
+    MINUTES_WRITING = "minutes_writing"
+}
+export interface MetricEntry {
+    date: CompactDate;
+    amount: number;
+}
+export interface MetricPayload {
+    metric_name: string;
+    min_date: CompactDate;
+    max_date: CompactDate;
+    entries: {
+        [key: string]: number;
+    };
+}
+export interface MetricBody extends ContentBody {
+    meta: ContentMeta;
+    payload: MetricPayload;
+}
+export declare class Metric extends Content {
+    static makeMetricId(userId: ContentId, metricName: MetricName): ContentId;
+    static create(userId: ContentId, metricName: MetricName, entries: {
+        [key: string]: number;
+    }): Metric;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): MetricPayload;
+    get metricName(): string;
+    get minDate(): CompactDate;
+    get maxDate(): CompactDate;
+    get length(): number;
+    get(index: number): MetricEntry;
+    sumBetween(minDate: CompactDate, maxDate: CompactDate): number;
+    forDate(date: CompactDate): number;
+    nonZeroDayCount(): number;
+    setDateAmount(date: CompactDate, amount: number): void;
+    incrementDateAmounts(dateAmounts: {
+        [key: string]: number;
+    }): void;
+    static forEachEntry(body: MetricBody, callback: (entry: MetricEntry) => void): void;
+}

package/dist/models/content/Metric.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metric = exports.MetricName = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+dayjs_1.default.extend(utc_1.default);
+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");
+var MetricName;
+(function (MetricName) {
+    MetricName["WORD_COUNT"] = "word_count";
+    MetricName["MINUTES_WRITING"] = "minutes_writing";
+})(MetricName || (exports.MetricName = MetricName = {}));
+class Metric extends Content_1.Content {
+    static makeMetricId(userId, metricName) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-metric-" + metricName);
+    }
+    static create(userId, metricName, entries) {
+        const metricId = Metric.makeMetricId(userId, metricName);
+        // Find the min and max dates
+        let minDate = null;
+        let maxDate = null;
+        for (let d of Object.keys(entries)) {
+            const date = d;
+            if (minDate === null || Time_1.Time.compareDate(date, minDate) < 0) {
+                minDate = date;
+            }
+            if (maxDate === null || Time_1.Time.compareDate(date, maxDate) > 0) {
+                maxDate = date;
+            }
+        }
+        const now = Time_1.MultiClock.now();
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: metricId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.METRIC,
+                id: metricId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                metric_name: metricName,
+                min_date: minDate,
+                max_date: maxDate,
+                entries: entries
+            }
+        });
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Metric.payload");
+        return this.doc.data.payload;
+    }
+    get metricName() {
+        this.checkDisposed("Metric.name");
+        return this.payload.metric_name;
+    }
+    get minDate() {
+        this.checkDisposed("Metric.minDate");
+        return this.payload.min_date;
+    }
+    get maxDate() {
+        this.checkDisposed("Metric.maxDate");
+        return this.payload.max_date;
+    }
+    get length() {
+        this.checkDisposed("Metric.length");
+        const minMoment = dayjs_1.default.utc(this.minDate, Time_1.Time.DATE_FORMAT);
+        const maxMoment = dayjs_1.default.utc(this.maxDate, Time_1.Time.DATE_FORMAT);
+        return Math.abs(maxMoment.diff(minMoment, "days")) + 1;
+    }
+    get(index) {
+        this.checkDisposed("Metric.get");
+        if (index === 0) {
+            return {
+                date: this.minDate,
+                amount: this.forDate(this.minDate)
+            };
+        }
+        else {
+            const minMoment = dayjs_1.default.utc(this.minDate, Time_1.Time.DATE_FORMAT);
+            const offsetDate = minMoment.add(index, 'days').format(Time_1.Time.DATE_FORMAT);
+            return {
+                date: offsetDate,
+                amount: this.forDate(offsetDate)
+            };
+        }
+    }
+    sumBetween(minDate, maxDate) {
+        this.checkDisposed("Metric.sumBetween");
+        let sum = 0;
+        const dates = Time_1.Time.datesBetween(minDate, maxDate);
+        for (let i = 0, len = dates.length; i < len; i++) {
+            const date = dates[i];
+            sum += this.forDate(date);
+        }
+        return sum;
+    }
+    forDate(date) {
+        this.checkDisposed("Metric.forDate");
+        const map = this.payload.entries;
+        if (map.hasOwnProperty(date)) {
+            return map[date];
+        }
+        return 0.0;
+    }
+    nonZeroDayCount() {
+        this.checkDisposed("Metric.nonZeroDayCount");
+        let count = 0;
+        const map = this.payload.entries;
+        for (let date of Object.keys(map)) {
+            if (map[date] !== 0.0) {
+                count++;
+            }
+        }
+        return count;
+    }
+    setDateAmount(date, amount) {
+        this.checkDisposed("Metric.setDateAmount");
+        const prevMinDate = this.payload.min_date;
+        const prevMaxDate = this.payload.max_date;
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'entries', date], amount);
+        if (prevMinDate === null || Time_1.Time.compareDate(date, prevMinDate) < 0) {
+            batch.setPathValue(['payload', 'min_date'], date);
+        }
+        if (prevMaxDate === null || Time_1.Time.compareDate(date, prevMaxDate) > 0) {
+            batch.setPathValue(['payload', 'max_date'], date);
+        }
+        batch.commit();
+    }
+    incrementDateAmounts(dateAmounts) {
+        this.checkDisposed("Metric.incrementDateAmounts");
+        const prevMinDate = this.payload.min_date;
+        const prevMaxDate = this.payload.max_date;
+        let minDate = prevMinDate;
+        let maxDate = prevMaxDate;
+        const batch = new Operation_1.BatchOperation(this);
+        const dates = Object.keys(dateAmounts);
+        for (let i = 0; i < dates.length; i++) {
+            const date = dates[i];
+            const prevAmount = this.forDate(date);
+            const newAmount = dateAmounts[date];
+            batch.setPathValue(['payload', 'entries', date], prevAmount + newAmount);
+            if (minDate === null || Time_1.Time.compareDate(date, minDate) < 0) {
+                minDate = date;
+            }
+            if (maxDate === null || Time_1.Time.compareDate(date, maxDate) > 0) {
+                maxDate = date;
+            }
+        }
+        if (minDate != prevMinDate) {
+            batch.setPathValue(['payload', 'min_date'], minDate);
+        }
+        if (maxDate != prevMaxDate) {
+            batch.setPathValue(['payload', 'max_date'], maxDate);
+        }
+        batch.commit();
+    }
+    static forEachEntry(body, callback) {
+        const dates = Object.keys(body.payload.entries);
+        for (let i = 0; i < dates.length; i++) {
+            const date = dates[i];
+            const amount = body.payload.entries[date];
+            callback({
+                date: date,
+                amount: amount
+            });
+        }
+    }
+}
+exports.Metric = Metric;

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

@@ -0,0 +1,68 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { LegacyContentKind, LegacyLocator } from '../legacy';
+import { Content, ContentId, ContentMeta, ContentRef } from "./Content";
+import { ContentKind } from './ContentKind';
+import { MultiTime } from './Time';
+export declare enum MigrationStatus {
+    MIGRATED = "MIGRATED",
+    CANT_MIGRATE = "CANT_MIGRATE",
+    REPAIRED = "REPAIRED",
+    CANT_REPAIR = "CANT_REPAIR",
+    SKIPPED = "SKIPPED",
+    UPDATED = "UPDATED"
+}
+export interface MigrationBody {
+    meta: ContentMeta;
+    payload: MigrationPayload;
+}
+export interface MigrationEntry {
+    at: MultiTime;
+    status: string;
+    message?: string;
+    models: MigrationModel[];
+}
+export interface MigrationModel {
+    legacy_kind?: LegacyContentKind;
+    legacy_locator?: LegacyLocator;
+    modern_kind?: ContentKind;
+    modern_id?: ContentId;
+    modern_ref?: ContentRef;
+}
+export interface MigrationPayload {
+    start: MultiTime;
+    end: MultiTime;
+    duration_minutes: number;
+    is_primary: boolean;
+    is_complete: boolean;
+    device_id: string;
+    legacy_snapshot_count: number;
+    repaired_count: number;
+    cant_repair_count: number;
+    migrated_count: number;
+    cant_migrate_count: number;
+    updated_count: number;
+    skipped_count: number;
+    migration_entries: MigrationEntry[];
+}
+export declare class Migration extends Content {
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    static makeMigrationId(userId: ContentId): ContentId;
+    static create(userId: ContentId, isPrimary: boolean, deviceId: ContentId): Migration;
+    get payload(): MigrationPayload;
+    get durationMinutes(): number;
+    get isPrimary(): boolean;
+    get isComplete(): boolean;
+    setIsComplete(value: boolean): void;
+    get legacySnapshotCount(): number;
+    setLegacySnapshotCount(value: number): void;
+    get repairedCount(): number;
+    get cantRepairCount(): number;
+    get migratedCount(): number;
+    get cantMigrateCount(): number;
+    get updatedCount(): number;
+    get skippedCount(): number;
+    addMigrationEntry(entry: MigrationEntry): void;
+    private touch;
+}