@shaxpir/duiduidui-models 1.0.0

package/dist/models/legacy/LegacyConversion.js

@@ -0,0 +1,401 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyConversion = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+dayjs_1.default.extend(utc_1.default);
+const Struct_1 = require("../../util/Struct");
+const content_1 = require("../content");
+const ConceptArt_1 = require("../content/ConceptArt");
+const Content_1 = require("../content/Content");
+const ContentKind_1 = require("../content/ContentKind");
+const Environment_1 = require("../content/Environment");
+const Profile_1 = require("../content/Profile");
+const RichText_1 = require("../content/RichText");
+const Session_1 = require("../content/Session");
+const Time_1 = require("../content/Time");
+const Workspace_1 = require("../content/Workspace");
+const BodyFormat_1 = require("../markup/BodyFormat");
+const LegacyContent_1 = require("./LegacyContent");
+const LegacyLocator_1 = require("./LegacyLocator");
+class LegacyConversion {
+    constructor(userId) {
+        this.userId = userId;
+    }
+    static convertDateTime(timestamp) {
+        return dayjs_1.default.utc(timestamp, Time_1.Time.DATETIME_FORMAT_LEGACY).format(Time_1.Time.DATETIME_FORMAT_COMPACT);
+    }
+    static convertOutboundMessage(message) {
+        let converted = Struct_1.Struct.clone(message);
+        converted.at_utc_time = LegacyConversion.convertDateTime(converted.at_utc_time);
+        return converted;
+    }
+    convertKind(legacyKind) {
+        if (legacyKind === LegacyContent_1.LegacyContentKind.STORY) {
+            return ContentKind_1.ContentKind.BOOK;
+        }
+        else if (legacyKind === LegacyContent_1.LegacyContentKind.PICTURE) {
+            return ContentKind_1.ContentKind.CONCEPT_ART;
+        }
+        else {
+            return legacyKind;
+        }
+    }
+    convertId(record) {
+        let id = record.id;
+        if (record.kind === LegacyContent_1.LegacyContentKind.SESSION) {
+            id = Session_1.Session.makeSessionId(this.userId);
+        }
+        else if (record.kind === LegacyContent_1.LegacyContentKind.WORKSPACE) {
+            id = Workspace_1.Workspace.makeWorkspaceId(this.userId);
+        }
+        else if (record.kind === LegacyContent_1.LegacyContentKind.PROFILE) {
+            id = Profile_1.Profile.makeProfileId(this.userId);
+        }
+        return id;
+    }
+    convertMeta(legacyRecord, createdAt, isHead) {
+        let convertedId = this.convertId(legacyRecord);
+        let kind = this.convertKind(legacyRecord.kind);
+        let updatedAt = this.convertMetaAt(legacyRecord);
+        let ref = isHead ? convertedId : Content_1.Content.makeContentRef(convertedId, createdAt.utc_time);
+        let meta = {
+            ref: ref,
+            is_head: isHead,
+            kind: kind,
+            id: convertedId,
+            created_at: createdAt,
+            updated_at: updatedAt,
+            owner: this.userId
+        };
+        if (isHead) {
+            meta.checkpoints = [];
+        }
+        return meta;
+    }
+    convertMetaAt(legacyRecord) {
+        let extraMillis = 0;
+        if (legacyRecord.kind == LegacyContent_1.LegacyContentKind.SESSION) {
+            // Handle some corrupt legacy data where there are multiple sessions with identical
+            // start timestamps by adding the sequence-number of the session to the start time
+            // in milliseconds. This should give us unique session IDs.
+            extraMillis = legacyRecord.seq;
+        }
+        return this.convertMultiTime(legacyRecord.at, extraMillis);
+    }
+    convertMultiTime(at, extraMillis) {
+        let atUtcTime = LegacyConversion.convertDateTime(at.utc_time);
+        let atLocalTime = LegacyConversion.convertDateTime(at.local_time);
+        if (extraMillis != 0) {
+            // Handle some corrupt legacy data where there are multiple sessions with identical
+            // start timestamps by adding the sequence-number of the session to the start time
+            // in milliseconds. This should give us unique session IDs.
+            atUtcTime = Time_1.Time.plus(atUtcTime, extraMillis, 'milliseconds');
+            atLocalTime = Time_1.Time.plus(atLocalTime, extraMillis, 'milliseconds');
+        }
+        return {
+            utc_time: atUtcTime,
+            local_time: atLocalTime
+        };
+    }
+    convertLegacyPayload(legacyRecord) {
+        return Struct_1.Struct.clone(legacyRecord.payload);
+    }
+    convertRichTextPayload(legacyBodyFormat) {
+        let converted = this.convertLegacyPayload(legacyBodyFormat);
+        converted.richtext_flavor = RichText_1.RichTextFlavor.quill;
+        converted.richtext_body = { ops: BodyFormat_1.BodyFormatModel.toDeltaOps(legacyBodyFormat.payload) };
+        delete converted.body;
+        delete converted.format;
+        return converted;
+    }
+    convertUser(legacyUser) {
+        let userId = legacyUser.id;
+        return {
+            email: legacyUser.payload.email,
+            force_password_reset: legacyUser.payload.force_password_reset,
+            pass_md5_salt_md5: legacyUser.payload.pass_md5_salt_md5,
+            salt: legacyUser.payload.salt,
+            profile_id: Profile_1.Profile.makeProfileId(userId),
+            session_id: Session_1.Session.makeSessionId(userId),
+            workspace_id: Workspace_1.Workspace.makeWorkspaceId(userId)
+        };
+    }
+    convertBilling(legacyUser, convertedTransactions) {
+        return {
+            plan: legacyUser.payload.plan,
+            paid_until: LegacyConversion.convertDateTime(legacyUser.payload.paid_until),
+            payment_status: legacyUser.payload.payment_status,
+            stripe_customer_id: legacyUser.payload.stripe_customer_id,
+            credit_card: legacyUser.payload.credit_card,
+            transactions: convertedTransactions
+        };
+    }
+    convertProfile(legacyProfile, createdAt, legacyAvatar) {
+        let payload = this.convertLegacyPayload(legacyProfile);
+        payload.username = null;
+        payload.avatar_media_ref = legacyProfile.payload.avatar;
+        payload.avatar_cropping = null;
+        if (legacyAvatar && legacyAvatar.payload.cropping) {
+            payload.avatar_cropping = Struct_1.Struct.clone(legacyAvatar.payload.cropping);
+        }
+        delete payload.avatar;
+        return {
+            meta: this.convertMeta(legacyProfile, createdAt, true),
+            payload: payload
+        };
+    }
+    convertWorkspace(legacyWorkspace, createdAt, newSessionTimetsamps, contentHeadStubsById) {
+        if (legacyWorkspace.payload.hasOwnProperty("stories")) {
+            legacyWorkspace.payload.books = Struct_1.Struct.clone(legacyWorkspace.payload.stories);
+            delete legacyWorkspace.stories;
+        }
+        let payload = this.convertLegacyPayload(legacyWorkspace);
+        payload.books = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.books);
+        payload.shorts = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.shorts);
+        payload.articles = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.articles);
+        payload.poems = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.poems);
+        payload.ideas = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.ideas);
+        payload.trash = this.convertStubArray(contentHeadStubsById, legacyWorkspace.payload.trash);
+        payload.devices = [];
+        payload.sessions = Time_1.Time.sortByUtcTime(Struct_1.Struct.clone(newSessionTimetsamps));
+        // UX and HighlightRules have been moved to Device models.
+        delete payload.ux;
+        delete payload.highlight;
+        // Primary device settings will be updated directly, during migration.
+        delete payload.primary_device;
+        delete payload.primary_device_last_update;
+        return {
+            meta: this.convertMeta(legacyWorkspace, createdAt, true),
+            payload: payload
+        };
+    }
+    convertSession(legacySession, checkpointTable) {
+        let payload = this.convertLegacyPayload(legacySession);
+        payload.activity = this.convertActivityArray(legacySession.payload.activity, checkpointTable);
+        payload.start = this.convertMultiTime(legacySession.payload.start, legacySession.seq);
+        payload.end = this.convertMultiTime(legacySession.at, legacySession.seq);
+        let meta = this.convertMeta(legacySession, payload.start, false);
+        // Move session duration from 'minutes_of.total' to 'duration_minutes', and rewrite null values as zeros.
+        payload.duration_minutes = legacySession.payload.minutes_of.total;
+        if (payload.duration_minutes == null) {
+            payload.duration_minutes = 0;
+        }
+        delete payload.minutes_of;
+        // Move device ID from 'environment.device_id' to 'device_id'
+        payload.device_id = legacySession.payload.environment.device_id;
+        delete payload.environment.device_id;
+        // Fixup missing operating-system version names for Mac OS
+        payload.environment.versions.os_version = Environment_1.EnvironmentModel.getOsVersion(payload.environment.versions.os_type, payload.environment.versions.os_release);
+        // Fixup missing 'shaxpir_bundle' version property
+        payload.environment.versions.shaxpir_bundle = payload.environment.versions.shaxpir;
+        payload.environment.versions.is_bundle_update = false;
+        return {
+            meta: meta,
+            payload: payload
+        };
+    }
+    convertTransactionPayload(legacyTransaction) {
+        let converted = Struct_1.Struct.clone(legacyTransaction.payload);
+        converted.at_utc_time = LegacyConversion.convertDateTime(legacyTransaction.at.utc_time);
+        if (converted.hasOwnProperty("details") && Object.keys(converted.details).length === 0) {
+            delete converted.details;
+        }
+        if (converted.details && converted.details.period) {
+            converted.details.period.start = LegacyConversion.convertDateTime(converted.details.period.start);
+            converted.details.period.end = LegacyConversion.convertDateTime(converted.details.period.end);
+        }
+        return converted;
+    }
+    convertBook(legacyStory, createdAt, contentHeadStubsById) {
+        let payload = this.convertLegacyPayload(legacyStory);
+        // Some very old book objects might be missing these properties
+        if (legacyStory.payload.hasOwnProperty("cover_art_id")) {
+            payload.cover_media_ref = legacyStory.payload.cover_art_id;
+            delete payload.cover_art_id;
+        }
+        else {
+            payload.cover_media_ref = null;
+        }
+        if (payload.hasOwnProperty("synopsis_id")) {
+            payload.synopsis_ref = payload.synopsis_id;
+            delete payload.synopsis_id;
+        }
+        else {
+            payload.synopsis_ref = null; // TODO: we need to create a fragment!
+        }
+        payload.manuscript = this.convertStubArray(contentHeadStubsById, legacyStory.payload.manuscript);
+        payload.notebook = this.convertStubArray(contentHeadStubsById, legacyStory.payload.notebook);
+        payload.trash = this.convertStubArray(contentHeadStubsById, legacyStory.payload.trash);
+        if (!payload.hasOwnProperty("export_options")) {
+            payload.export_options = content_1.ExportOptionsModel.build(payload);
+        }
+        return {
+            meta: this.convertMeta(legacyStory, createdAt, true),
+            payload: payload
+        };
+    }
+    convertCheckpoints(legacyCheckpoints) {
+        // Create the checkpoint bodies
+        let checkpoints = [];
+        for (let i = 0; i < legacyCheckpoints.length; i++) {
+            let legacyCheckpoint = legacyCheckpoints[i];
+            // Checkpoints have the same timestamp for createdAt and updatedAt
+            let createdAt = this.convertMetaAt(legacyCheckpoint);
+            let kind = this.convertKind(legacyCheckpoint.kind);
+            let converted;
+            if (kind === ContentKind_1.ContentKind.FRAGMENT) {
+                converted = this.convertFragment(legacyCheckpoint, createdAt, false);
+            }
+            else if (kind === ContentKind_1.ContentKind.COMMENT) {
+                converted = this.convertComment(legacyCheckpoint, createdAt, false);
+            }
+            else if (kind === ContentKind_1.ContentKind.CONCEPT_ART) {
+                converted = this.convertPictureToConceptArt(legacyCheckpoint, createdAt, false);
+            }
+            checkpoints.push(converted);
+        }
+        return checkpoints;
+    }
+    convertFragment(legacyFragment, createdAt, isHead) {
+        let payload = this.convertRichTextPayload(legacyFragment);
+        payload.book_ids = this.convertArrayOfLocators(legacyFragment.payload.stories);
+        payload.gallery = this.convertArrayOfLocators(legacyFragment.payload.pictures);
+        delete payload.stories;
+        delete payload.pictures;
+        delete payload.comments;
+        // The IDs in the LegacyFragment were "picture" IDs, and "Picture" objects contained the data now split between
+        // Media and ConceptArt objects. So now we need to generate "ConceptArt" IDs to go into this list. Media IDs are
+        // the same as the Picture IDs from whence they sprung, but ConceptArt IDs are derived from Media IDs.
+        for (let i = 0; i < payload.gallery.length; i++) {
+            const mediaId = payload.gallery[i];
+            payload.gallery[i] = ConceptArt_1.ConceptArt.makeConceptArtIdForMedia(mediaId);
+        }
+        // Connections have been updated to use refs instead of locators
+        let connections = [];
+        for (let i = 0; i < legacyFragment.payload.connections.length; i++) {
+            let section = legacyFragment.payload.connections[i];
+            connections.push({
+                label: section.label,
+                refs: this.convertArrayOfLocators(section.locators)
+            });
+        }
+        payload.connections = connections;
+        payload.robot_lock = null;
+        return {
+            meta: this.convertMeta(legacyFragment, createdAt, isHead),
+            payload: payload
+        };
+    }
+    convertPictureToMedia(legacyPicture, createdAt) {
+        // Convert the payload
+        let mediaPayload = Struct_1.Struct.clone(legacyPicture.payload);
+        delete mediaPayload.name;
+        delete mediaPayload.body;
+        delete mediaPayload.format;
+        delete mediaPayload.word_count;
+        delete mediaPayload.cropping;
+        delete mediaPayload.references;
+        // Convert the meta
+        let meta = this.convertMeta(legacyPicture, createdAt, true);
+        meta.kind = ContentKind_1.ContentKind.MEDIA;
+        return {
+            meta: meta,
+            payload: mediaPayload
+        };
+    }
+    convertPictureToConceptArt(legacyPicture, createdAt, isHead) {
+        let payload = this.convertRichTextPayload(legacyPicture);
+        payload.media_ref = legacyPicture.id;
+        delete payload.extension;
+        delete payload.bytes;
+        delete payload.width;
+        delete payload.height;
+        // All LegacyPicture objects have a one-to-one relationship with a pair of modern ConceptArt and Media objects.
+        // But that won't necessarily always be the case in the future. Let's use a hash to create a new unique ID, but
+        // one that doesn't necessarily invoke its prevenance at a glance. So in the future, we'll be able to generate
+        // arbitrary ConceptArt objects without necessarily a one-to-one relationship with a corresponding Media object.
+        let meta = this.convertMeta(legacyPicture, createdAt, isHead);
+        meta.kind = ContentKind_1.ContentKind.CONCEPT_ART;
+        meta.id = ConceptArt_1.ConceptArt.makeConceptArtIdForMedia(meta.id);
+        meta.ref = isHead ? meta.id : Content_1.Content.makeContentRef(meta.id, meta.updated_at.utc_time);
+        return {
+            meta: meta,
+            payload: payload
+        };
+    }
+    convertComment(legacyComment, createdAt, isHead) {
+        let meta = this.convertMeta(legacyComment, createdAt, isHead);
+        let payload = this.convertRichTextPayload(legacyComment);
+        payload.anchor = legacyComment.payload.anchor;
+        return {
+            meta: meta,
+            payload: payload
+        };
+    }
+    convertArrayOfLocators(locators) {
+        let contentIds = new Array();
+        for (let i = 0; i < locators.length; i++) {
+            contentIds[i] = LegacyLocator_1.LegacyLocatorModel.headOf(locators[i]);
+        }
+        return contentIds;
+    }
+    convertActivityArray(activity, checkpointTable) {
+        let newActivity = [];
+        // The new Activity array only cares about fragments, comments, and pictures.
+        for (let i = 0, len = activity.length; i < len; i++) {
+            let activityEntry = activity[i];
+            if (activityEntry.kind === LegacyContent_1.LegacyContentKind.FRAGMENT ||
+                activityEntry.kind === LegacyContent_1.LegacyContentKind.COMMENT ||
+                activityEntry.kind === LegacyContent_1.LegacyContentKind.PICTURE) {
+                let convertedBefore = null;
+                if (activityEntry.versions.before != null) {
+                    convertedBefore = checkpointTable.get(activityEntry.versions.before);
+                }
+                let convertedAfter = checkpointTable.get(activityEntry.versions.after);
+                newActivity.push({
+                    kind: this.convertKind(activityEntry.kind),
+                    id: activityEntry.id,
+                    before: convertedBefore,
+                    after: convertedAfter,
+                    word_count: activityEntry.word_count
+                });
+            }
+        }
+        return newActivity;
+    }
+    convertStubArray(contentHeadStubsById, stubs) {
+        let newStubArray = [];
+        for (let i = 0, len = stubs.length; i < len; i++) {
+            let stub = stubs[i];
+            if (typeof (stub) === "string") {
+                // If this stub is just a raw string (a rare legacy possibility), replace it with a real stub object.
+                let contentId = LegacyLocator_1.LegacyLocatorModel.headOf(stub);
+                if (contentHeadStubsById.has(contentId)) {
+                    newStubArray.push(Struct_1.Struct.clone(contentHeadStubsById.get(contentId)));
+                }
+            }
+            else if (stub.kind === LegacyContent_1.LegacyContentKind.FOLDER) {
+                // If this is a folder stub, just keep it. It doesn't need any changes.
+                newStubArray.push(stub);
+            }
+            else if (stub) {
+                // If this is a normal stub, replace it with the canonical version (with name & category included) from the lookup table.
+                let contentStub = stub;
+                let contentId = LegacyLocator_1.LegacyLocatorModel.headOf(contentStub.locator);
+                if (contentHeadStubsById.has(contentId)) {
+                    let s = Struct_1.Struct.clone(contentHeadStubsById.get(contentId));
+                    newStubArray.push(s);
+                    if (contentStub.hasOwnProperty("parent") && contentStub.parent != null) {
+                        s.parent = LegacyLocator_1.LegacyLocatorModel.headOf(contentStub.parent);
+                    }
+                }
+            }
+        }
+        return newStubArray;
+    }
+}
+exports.LegacyConversion = LegacyConversion;

package/dist/models/legacy/LegacyFragment.d.ts

@@ -0,0 +1,21 @@
+import { Category } from "../content/Category";
+import { LegacyBodyFormat, LegacyBodyFormatPayload } from "./LegacyBodyFormat";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+export interface LegacyConnection {
+    label: string;
+    locators: LegacyHeadLocator[];
+}
+export interface LegacyFragmentPayload extends LegacyBodyFormatPayload {
+    name: string;
+    category: Category;
+    stories?: LegacyLocator[];
+    books?: LegacyLocator[];
+    comments: LegacyLocator[];
+    pictures?: LegacyLocator[];
+    gallery?: LegacyLocator[];
+    connections: LegacyConnection[];
+    word_count: number;
+}
+export interface LegacyFragment extends LegacyBodyFormat {
+    payload: LegacyFragmentPayload;
+}

package/dist/models/legacy/LegacyFragment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/legacy/LegacyLocator.d.ts

@@ -0,0 +1,8 @@
+export type LegacyHeadLocator = string;
+export type LegacyLocator = string;
+export declare class LegacyLocatorModel {
+    static isHead(locator: LegacyLocator): boolean;
+    static headOf(locator: LegacyLocator): LegacyHeadLocator;
+    static seqOf(locator: LegacyLocator): number;
+    static create(id: LegacyHeadLocator, seq?: number): LegacyLocator;
+}

package/dist/models/legacy/LegacyLocator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyLocatorModel = void 0;
+class LegacyLocatorModel {
+    static isHead(locator) {
+        let parts = locator.split('-');
+        return parts.length === 1;
+    }
+    static headOf(locator) {
+        let parts = locator.split('-');
+        return parts[0];
+    }
+    static seqOf(locator) {
+        let parts = locator.split('-');
+        if (parts.length > 1) {
+            return Number(parts[1]);
+        }
+        else {
+            return null;
+        }
+    }
+    static create(id, seq) {
+        if (typeof (seq) === "number") {
+            return id + "-" + seq;
+        }
+        else {
+            return id;
+        }
+    }
+}
+exports.LegacyLocatorModel = LegacyLocatorModel;

package/dist/models/legacy/LegacyOutboundMessage.d.ts

@@ -0,0 +1,16 @@
+import { OutboundChannel, OutboundMessage } from "../OutboundMessage";
+import { LegacyDateTime } from "./LegacyContent";
+export interface LegacyOutboundMessage {
+    id: string;
+    at_utc_time: LegacyDateTime;
+    user_id: string;
+    campaign: string;
+    channel: OutboundChannel;
+    template: string;
+    recipient: string;
+    dryrun: boolean;
+    params: any;
+}
+export declare class LegacyOutboundMessageModel {
+    static toLegacy(message: OutboundMessage): LegacyOutboundMessage;
+}

package/dist/models/legacy/LegacyOutboundMessage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyOutboundMessageModel = void 0;
+const Struct_1 = require("../../util/Struct");
+const LegacyContent_1 = require("./LegacyContent");
+class LegacyOutboundMessageModel {
+    static toLegacy(message) {
+        let legacy = Struct_1.Struct.clone(message);
+        legacy.at_utc_time = LegacyContent_1.LegacyClock.fromCompact(message.at_utc_time);
+        return legacy;
+    }
+}
+exports.LegacyOutboundMessageModel = LegacyOutboundMessageModel;

package/dist/models/legacy/LegacyPicture.d.ts

@@ -0,0 +1,14 @@
+import { MediaCropping, MediaDimensions } from "../content/Media";
+import { LegacyBodyFormat, LegacyBodyFormatPayload } from "./LegacyBodyFormat";
+import { LegacyLocator } from "./LegacyLocator";
+export interface LegacyPicturePayload extends LegacyBodyFormatPayload, MediaDimensions {
+    name: string;
+    extension: string;
+    references: LegacyLocator[];
+    bytes: number;
+    cropping: MediaCropping;
+    word_count: number;
+}
+export interface LegacyPicture extends LegacyBodyFormat {
+    payload: LegacyPicturePayload;
+}

package/dist/models/legacy/LegacyPicture.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/legacy/LegacyProfile.d.ts

@@ -0,0 +1,9 @@
+import { LegacyContent } from "./LegacyContent";
+import { LegacyHeadLocator } from "./LegacyLocator";
+export interface LegacyProfilePayload {
+    full_name: string;
+    avatar: LegacyHeadLocator;
+}
+export interface LegacyProfile extends LegacyContent {
+    payload: LegacyProfilePayload;
+}

package/dist/models/legacy/LegacyProfile.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/legacy/LegacySession.d.ts

@@ -0,0 +1,41 @@
+import { ContentId, GeoLocation, Screens, StorageDevice, Versions } from "../content";
+import { LegacyContent, LegacyContentKind, LegacyMultiTime } from "./LegacyContent";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+export interface LegacyActivityVersions {
+    before: LegacyLocator | null;
+    after: LegacyLocator;
+}
+export interface LegacyActivity {
+    kind: LegacyContentKind;
+    id: LegacyHeadLocator;
+    versions: LegacyActivityVersions;
+    word_count?: number;
+    total_word_count?: number;
+}
+export interface MinutesOf {
+    total: number;
+}
+export interface LegacySessionPayload {
+    start: LegacyMultiTime;
+    tz_offset: number;
+    minutes_of: MinutesOf;
+    environment: LegacyEnvironment;
+    word_count: number;
+    activity: LegacyActivity[];
+}
+export interface LegacyEnvironment {
+    device_id: ContentId;
+    versions: Versions;
+    memory: number;
+    storage: StorageDevice[];
+    screens: Screens;
+    language: string;
+    location: GeoLocation;
+}
+export interface LegacySession extends LegacyContent {
+    payload: LegacySessionPayload;
+}
+export declare class LegacyActivityModel {
+    static summarize(content: LegacyContent, prev: LegacyContent): LegacyActivity;
+    static addMetricsChangeToSummary(summary: LegacyActivity, content: LegacyContent, prev: LegacyContent, metricsName: "word_count" | "total_word_count"): void;
+}

package/dist/models/legacy/LegacySession.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyActivityModel = void 0;
+class LegacyActivityModel {
+    static summarize(content, prev) {
+        // TODO: the activity stream will eventually contain all sorts of interesting
+        // stuff about renaming content items, changing map positions, adding and removing
+        // pictures, etc. But for now, let's just keep it limited to word-counting.
+        // It only makes sense to summarize the change-activity if these two content items have the same ID
+        if (prev != null && prev.id !== content.id) {
+            throw new Error("can\x27t summarize activity for content with disjunct ids: " + prev.id + ", " + content.id);
+        }
+        let summary = {
+            "kind": content.kind,
+            "id": content.id,
+            "versions": {
+                "before": prev == null ? null : prev.locator,
+                "after": content.locator
+            }
+        };
+        LegacyActivityModel.addMetricsChangeToSummary(summary, content, prev, "word_count");
+        LegacyActivityModel.addMetricsChangeToSummary(summary, content, prev, "total_word_count");
+        return summary;
+    }
+    static addMetricsChangeToSummary(summary, content, prev, metricsName) {
+        if (content.payload.hasOwnProperty(metricsName)) {
+            let wordCountChange = content.payload[metricsName];
+            if (prev !== null && prev.payload.hasOwnProperty(metricsName)) {
+                wordCountChange -= prev.payload[metricsName];
+            }
+            summary[metricsName] = wordCountChange;
+        }
+    }
+}
+exports.LegacyActivityModel = LegacyActivityModel;

package/dist/models/legacy/LegacyStory.d.ts

@@ -0,0 +1,23 @@
+import { ExportOptions } from "../content/ExportOptions";
+import { LegacyContent } from "./LegacyContent";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+import { LegacyStub } from "./LegacyStub";
+export interface LegacyStoryPayload {
+    name: string;
+    subtitle: string;
+    synopsis_id: LegacyHeadLocator | null;
+    cover_art_id: LegacyHeadLocator | null;
+    author: string;
+    contributors: LegacyLocator[];
+    copyright: string;
+    publisher: string;
+    isbn: string;
+    manuscript: LegacyStub[];
+    notebook: LegacyStub[];
+    export_options: ExportOptions;
+    trash: Array<LegacyStub | LegacyHeadLocator>;
+    total_word_count: number;
+}
+export interface LegacyStory extends LegacyContent {
+    payload: LegacyStoryPayload;
+}

package/dist/models/legacy/LegacyStory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/legacy/LegacyStub.d.ts

@@ -0,0 +1,15 @@
+import { LegacyContentKind } from "./LegacyContent";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+export interface LegacyStub {
+    kind: LegacyContentKind;
+    label: string;
+    parent?: LegacyHeadLocator;
+    children?: LegacyStub[];
+}
+export interface LegacyFolderStub extends LegacyStub {
+    id: LegacyHeadLocator;
+}
+export interface LegacyContentStub extends LegacyStub {
+    category?: string;
+    locator: LegacyLocator;
+}

package/dist/models/legacy/LegacyStub.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });