@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Book.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Book = exports.BookStubArrayKey = exports.BookType = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const Struct_1 = require("../../util/Struct");
+const Operation_1 = require("../markup/Operation");
+const ArrayView_1 = require("./ArrayView");
+const Category_1 = require("./Category");
+const ContentKind_1 = require("./ContentKind");
+const Context_1 = require("./Context");
+const ExportOptions_1 = require("./ExportOptions");
+const Folder_1 = require("./Folder");
+const Fragment_1 = require("./Fragment");
+const Placeholder_1 = require("./Placeholder");
+const Stub_1 = require("./Stub");
+const Time_1 = require("./Time");
+const Workspace_1 = require("./Workspace");
+var BookType;
+(function (BookType) {
+    BookType["FICTION"] = "fiction";
+    BookType["NONFICTION"] = "non-fiction";
+    BookType["EMPTY"] = "empty";
+})(BookType || (exports.BookType = BookType = {}));
+var BookStubArrayKey;
+(function (BookStubArrayKey) {
+    BookStubArrayKey["MANUSCRIPT"] = "manuscript";
+    BookStubArrayKey["NOTEBOOK"] = "notebook";
+    BookStubArrayKey["TRASH"] = "trash";
+})(BookStubArrayKey || (exports.BookStubArrayKey = BookStubArrayKey = {}));
+class Book extends Context_1.Context {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+        this._manuscriptView = new ArrayView_1.ArrayView(this, ['payload', 'manuscript']);
+        this._notebookView = new ArrayView_1.ArrayView(this, ['payload', 'notebook']);
+    }
+    get payload() {
+        this.checkDisposed("Book.payload");
+        return this.doc.data.payload;
+    }
+    static create(userId, template) {
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        const bookId = shareSync.makeContentId();
+        // Create a synopsis and a chapter
+        const synopsis = Fragment_1.Fragment.create(userId, bookId, Category_1.Category.SYNOPSIS);
+        const chapter = Fragment_1.Fragment.create(userId, bookId, Category_1.Category.CHAPTER);
+        // Add three folders to the notebook
+        const notebookStubs = [];
+        if (template === BookType.FICTION) {
+            notebookStubs.push(Folder_1.Folder.create("CHARACTERS"));
+            notebookStubs.push(Folder_1.Folder.create("PLACES"));
+            notebookStubs.push(Folder_1.Folder.create("THEMES"));
+        }
+        else if (template === BookType.NONFICTION) {
+            notebookStubs.push(Folder_1.Folder.create("TOPICS"));
+            notebookStubs.push(Folder_1.Folder.create("RESOURCES"));
+            notebookStubs.push(Folder_1.Folder.create("QUESTIONS"));
+        }
+        const manuscriptStubs = [
+            {
+                kind: ContentKind_1.ContentKind.FRAGMENT,
+                category: Category_1.Category.CHAPTER,
+                ref: chapter.id,
+                label: ""
+            }
+        ];
+        const now = Time_1.MultiClock.now();
+        return shareSync.createContent({
+            meta: {
+                ref: bookId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.BOOK,
+                id: bookId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                name: "",
+                subtitle: "",
+                author: "",
+                contributors: new Array(),
+                copyright: "© " + Time_1.Time.currentYear(),
+                publisher: "",
+                isbn: "",
+                synopsis_ref: synopsis.id,
+                cover_media_ref: null,
+                manuscript: manuscriptStubs,
+                notebook: notebookStubs,
+                trash: [],
+                export_options: ExportOptions_1.ExportOptionsModel.makeDefaultOptions(),
+                total_word_count: 0
+            }
+        });
+    }
+    get coverMediaRef() {
+        this.checkDisposed("Book.coverMediaRef");
+        return this.payload.cover_media_ref;
+    }
+    setCoverMediaRef(value) {
+        this.checkDisposed("Book.setCoverMediaRef");
+        if (this.coverMediaRef != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'cover_media_ref'], value);
+            batch.commit();
+        }
+    }
+    get synopsisRef() {
+        this.checkDisposed("Book.synopsisRef");
+        return this.payload.synopsis_ref;
+    }
+    setSynopsisId(value) {
+        this.checkDisposed("Book.setSynopsisId");
+        if (this.synopsisRef != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'synopsis_ref'], value);
+            batch.commit();
+        }
+    }
+    get name() {
+        this.checkDisposed("Book.name");
+        return this.payload.name;
+    }
+    setName(value) {
+        this.checkDisposed("Book.setName");
+        if (this.name != value) {
+            const book = this;
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'name'], value);
+            batch.commit();
+            // Update the name of this book in the workspace stub arrays.
+            const workspaceId = Workspace_1.Workspace.makeWorkspaceId(book.meta.owner);
+            ShareSync_1.ShareSyncFactory.get().acquire(ContentKind_1.ContentKind.WORKSPACE, workspaceId).then((workspace) => {
+                workspace.editStubFieldText(book.id, 'label', book.name);
+                workspace.release();
+            });
+        }
+    }
+    get subtitle() {
+        this.checkDisposed("Book.subtitle");
+        return this.payload.subtitle;
+    }
+    setSubtitle(value) {
+        this.checkDisposed("Book.setSubtitle");
+        if (this.subtitle != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'subtitle'], value);
+            batch.commit();
+        }
+    }
+    get author() {
+        this.checkDisposed("Book.author");
+        return this.payload.author;
+    }
+    setAuthor(value) {
+        this.checkDisposed("Book.setAuthor");
+        if (this.author != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'author'], value);
+            batch.commit();
+        }
+    }
+    get copyright() {
+        this.checkDisposed("Book.copyright");
+        return this.payload.copyright;
+    }
+    setCopyright(value) {
+        this.checkDisposed("Book.setCopyright");
+        if (this.copyright != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'copyright'], value);
+            batch.commit();
+        }
+    }
+    get publisher() {
+        this.checkDisposed("Book.publisher");
+        return this.payload.publisher;
+    }
+    setPublisher(value) {
+        this.checkDisposed("Book.setPublisher");
+        if (this.publisher != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'publisher'], value);
+            batch.commit();
+        }
+    }
+    get isbn() {
+        this.checkDisposed("Book.isbn");
+        return this.payload.isbn;
+    }
+    setIsbn(value) {
+        this.checkDisposed("Book.setIsbn");
+        if (this.isbn != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'isbn'], value);
+            batch.commit();
+        }
+    }
+    get totalWordCount() {
+        this.checkDisposed("Book.totalWordCount");
+        return this.payload.total_word_count;
+    }
+    get manuscript() {
+        this.checkDisposed("Book.manuscript");
+        return this._manuscriptView;
+    }
+    get notebook() {
+        this.checkDisposed("Book.notebook");
+        return this._notebookView;
+    }
+    get exportOptions() {
+        this.checkDisposed("Book.exportOptions");
+        return this.payload.export_options || null;
+    }
+    replaceExportOptions(newOptions) {
+        this.checkDisposed("Book.replaceExportOptions");
+        // This method does a parallel-walk of the old export-options and the new
+        // export-options, and performs a minimal set of batch operations to bring
+        // this book's own embedded export-options inline with the new options.
+        const oldOptions = (this.exportOptions || {});
+        if (!Struct_1.Struct.equals(oldOptions, newOptions)) {
+            const batch = new Operation_1.BatchOperation(this);
+            if (oldOptions.selected_format != newOptions.selected_format) {
+                batch.setPathValue(['payload', 'export_options', 'selected_format'], newOptions.selected_format);
+            }
+            const oldFormatNames = Object.keys(oldOptions.formats).sort();
+            const newFormatNames = Object.keys(newOptions.formats).sort();
+            const commonFormatNames = [];
+            for (let i = 0; i < oldFormatNames.length; i++) {
+                const oldFormatName = oldFormatNames[i];
+                if (newFormatNames.includes(oldFormatName)) {
+                    commonFormatNames.push(oldFormatName);
+                }
+                else {
+                    batch.removeValueAtPath(['payload', 'export_options', 'formats', oldFormatName]);
+                }
+            }
+            for (let i = 0; i < newFormatNames.length; i++) {
+                const newFormatName = newFormatNames[i];
+                if (!oldFormatNames.includes(newFormatName)) {
+                    const newFormatValue = newOptions.formats[newFormatName];
+                    batch.setPathValue(['payload', 'export_options', 'formats', newFormatName], newFormatValue);
+                }
+            }
+            for (let i = 0; i < commonFormatNames.length; i++) {
+                const formatName = commonFormatNames[i];
+                const oldFormatOptions = oldOptions.formats[formatName];
+                const newFormatOptions = newOptions.formats[formatName];
+                if (oldFormatOptions.include_toc != newFormatOptions.include_toc) {
+                    batch.setPathValue(['payload', 'export_options', 'formats', formatName, 'include_toc'], newFormatOptions.include_toc);
+                }
+                if (oldFormatOptions.include_synopsis != newFormatOptions.include_synopsis) {
+                    batch.setPathValue(['payload', 'export_options', 'formats', formatName, 'include_synopsis'], newFormatOptions.include_synopsis);
+                }
+                const stubKeys = ['manuscript', 'notebook'];
+                for (let j = 0; j < stubKeys.length; j++) {
+                    const stubKey = stubKeys[j];
+                    const oldStubKeyOptions = oldFormatOptions[stubKey];
+                    const newStubKeyOptions = newFormatOptions[stubKey];
+                    if (oldStubKeyOptions.include != newStubKeyOptions.include) {
+                        batch.setPathValue(['payload', 'export_options', 'formats', formatName, stubKey, 'include'], newStubKeyOptions.include);
+                    }
+                    const oldCategoryNames = Object.keys(oldStubKeyOptions.categories).sort();
+                    const newCategoryNames = Object.keys(newStubKeyOptions.categories).sort();
+                    const commonCategoryNames = [];
+                    for (let k = 0; k < oldCategoryNames.length; k++) {
+                        const oldCategoryName = oldCategoryNames[k];
+                        if (newCategoryNames.includes(oldCategoryName)) {
+                            commonCategoryNames.push(oldCategoryName);
+                        }
+                        else {
+                            batch.removeValueAtPath(['payload', 'export_options', 'formats', formatName, stubKey, 'categories', oldCategoryName]);
+                        }
+                    }
+                    for (let k = 0; k < newCategoryNames.length; k++) {
+                        const newCategoryName = newCategoryNames[k];
+                        if (!oldCategoryNames.includes(newCategoryName)) {
+                            const newCategoryOptions = newStubKeyOptions.categories[newCategoryName];
+                            batch.setPathValue(['payload', 'export_options', 'formats', formatName, stubKey, 'categories', newCategoryName], newCategoryOptions);
+                        }
+                    }
+                    for (let k = 0; k < commonCategoryNames.length; k++) {
+                        const categoryName = commonCategoryNames[k];
+                        const oldCategoryOptions = oldStubKeyOptions.categories[categoryName];
+                        const newCategoryOptions = newStubKeyOptions.categories[categoryName];
+                        const categoryOptionKeys = ['toc', 'name', 'number', 'prefix', 'brk'];
+                        for (let m = 0; m < categoryOptionKeys.length; m++) {
+                            const categoryOptionKey = categoryOptionKeys[m];
+                            const oldCategoryOptionValue = oldCategoryOptions[categoryOptionKey];
+                            const newCategoryOptionValue = newCategoryOptions[categoryOptionKey];
+                            if (oldCategoryOptionValue != newCategoryOptionValue) {
+                                batch.setPathValue(['payload', 'export_options', formatName, stubKey, 'categories', categoryName, categoryOptionKey], newCategoryOptionValue);
+                            }
+                        }
+                    }
+                }
+            }
+            batch.commit();
+        }
+    }
+    getStubArrayKeys() {
+        return [
+            BookStubArrayKey.MANUSCRIPT,
+            BookStubArrayKey.NOTEBOOK,
+            BookStubArrayKey.TRASH
+        ];
+    }
+    getStubArrayView(key) {
+        this.checkDisposed("Book.getStubArrayView");
+        if (key === BookStubArrayKey.MANUSCRIPT) {
+            return this._manuscriptView;
+        }
+        else if (key === BookStubArrayKey.NOTEBOOK) {
+            return this._notebookView;
+        }
+        else if (key === BookStubArrayKey.TRASH) {
+            return this._trashView;
+        }
+        return null;
+    }
+    addFragmentToManuscript(fragment, activeId) {
+        this.checkDisposed("Book.addFragmentToManuscript");
+        const stub = fragment.asStub();
+        if (fragment.category === Category_1.Category.FRONT_MATTER) {
+            // Always add front-matter to the front.
+            this.manuscript.unshift(stub);
+        }
+        else if (fragment.category === Category_1.Category.BACK_MATTER) {
+            // Always add back-matter to the back.
+            this.manuscript.push(stub);
+        }
+        else {
+            // All other content should be added to the most natural point, based on whatever content is currently active
+            Stub_1.Stubs.insertStubAtActivePoint(stub, this._manuscriptView, fragment.category, activeId, false);
+        }
+        if (fragment.wordCount > 0) {
+            this.updateWordCount();
+        }
+    }
+    addFragmentToNotebook(fragment, activeId) {
+        this.checkDisposed("Book.addFragmentToNotebook");
+        const stub = fragment.asStub();
+        Stub_1.Stubs.insertStubAtActivePoint(stub, this._notebookView, fragment.category, activeId, true);
+    }
+    async updateWordCount() {
+        this.checkDisposed("Book.updateWordCount");
+        const prevTotalWordCount = this.totalWordCount;
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        let totalWordCount = 0;
+        for (let i = 0, len = this.manuscript.length; i < len; i++) {
+            const stub = this.manuscript.get(i);
+            if (Stub_1.Stubs.isContentStub(stub)) {
+                // TODO: should we skip front-matter and back-matter fragments?
+                const ref = stub.ref;
+                const chapter = await shareSync.acquire(ContentKind_1.ContentKind.FRAGMENT, ref);
+                totalWordCount += chapter.wordCount;
+                chapter.release();
+            }
+        }
+        if (totalWordCount != prevTotalWordCount) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'total_word_count'], totalWordCount);
+            batch.commit();
+        }
+    }
+    getAllCategories(context) {
+        this.checkDisposed("Book.getAllCategories");
+        return Book.harvestUniqueCategories(this.payload, context);
+    }
+    getPlaceholder() {
+        this.checkDisposed("Book.getPlaceholder");
+        return Placeholder_1.Placeholder.forContent(this);
+    }
+    asStub() {
+        this.checkDisposed("Book.asStub");
+        return {
+            kind: ContentKind_1.ContentKind.BOOK,
+            ref: this.id,
+            label: this.name
+        };
+    }
+    static harvestUniqueCategories(bookPayload, context) {
+        const stubs = context === BookStubArrayKey.MANUSCRIPT ?
+            bookPayload.manuscript :
+            bookPayload.notebook;
+        const unique = [];
+        const categories = {};
+        for (let i = 0, len = stubs.length; i < len; i++) {
+            const stub = stubs[i];
+            let category = null;
+            if (Stub_1.Stubs.isFolderStub(stub)) {
+                category = ContentKind_1.ContentKind.FOLDER;
+            }
+            else if (Stub_1.Stubs.isContentStub(stub)) {
+                category = stub.category;
+            }
+            if (!categories.hasOwnProperty(category)) {
+                categories[category] = true;
+                unique.push(category);
+            }
+        }
+        return unique;
+    }
+    mergeIncomingContext(incomingBook) {
+        return super.mergeIncomingContext(incomingBook);
+    }
+}
+exports.Book = Book;

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

@@ -0,0 +1,16 @@
+export declare enum Category {
+    FRONT_MATTER = "front-matter",
+    BACK_MATTER = "back-matter",
+    FOLDER = "folder",
+    PART = "part",
+    CHAPTER = "chapter",
+    SCENE = "scene",
+    SYNOPSIS = "synopsis",
+    ARTICLE = "article",
+    SHORT_STORY = "short-story",
+    IDEA = "idea",
+    NOTE = "note",
+    CHARACTER = "character",
+    PLACE = "place",
+    THEME = "theme"
+}

package/dist/models/content/Category.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Category = void 0;
+var Category;
+(function (Category) {
+    Category["FRONT_MATTER"] = "front-matter";
+    Category["BACK_MATTER"] = "back-matter";
+    Category["FOLDER"] = "folder";
+    Category["PART"] = "part";
+    Category["CHAPTER"] = "chapter";
+    Category["SCENE"] = "scene";
+    Category["SYNOPSIS"] = "synopsis";
+    Category["ARTICLE"] = "article";
+    Category["SHORT_STORY"] = "short-story";
+    Category["IDEA"] = "idea";
+    Category["NOTE"] = "note";
+    Category["CHARACTER"] = "character";
+    Category["PLACE"] = "place";
+    Category["THEME"] = "theme";
+})(Category || (exports.Category = Category = {}));

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

@@ -0,0 +1,21 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { ArrayView } from './ArrayView';
+import { Content, ContentBody } from "./Content";
+import { CompactDateTime, MultiTime } from './Time';
+export declare abstract class Checkpointable extends Content {
+    private _checkpointsView;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get checkpoints(): ArrayView<CompactDateTime>;
+    hasCheckpoint(timestamp: CompactDateTime): boolean;
+    addCheckpoint(timestamp: CompactDateTime): boolean;
+    makeCheckpointBody(): ContentBody;
+    cloneCheckpoints(): CompactDateTime[];
+    recordCheckpoint(checkpointBody: ContentBody): void;
+    acquireLastCheckpoint(): Promise<Content>;
+    acquireLatestCheckpointAt(timestamp: CompactDateTime): Promise<Content>;
+    loadLatestCheckpointAt(timestamp: CompactDateTime): Promise<Content>;
+    beforeRestoreTo(checkpoint: Checkpointable, now: MultiTime): Promise<void>;
+    restoreTo(checkpoint: Checkpointable, now: MultiTime): Promise<void>;
+}

package/dist/models/content/Checkpointable.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkpointable = void 0;
+const util_1 = require("../../util");
+const Operation_1 = require("../markup/Operation");
+const ArrayView_1 = require("./ArrayView");
+const Content_1 = require("./Content");
+const Time_1 = require("./Time");
+class Checkpointable extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+        this._checkpointsView = null;
+        this._checkpointsView = new ArrayView_1.ArrayView(this, ['meta', 'checkpoints']);
+    }
+    get checkpoints() {
+        this.checkDisposed("Content.checkpoints");
+        return this._checkpointsView;
+    }
+    hasCheckpoint(timestamp) {
+        this.checkDisposed("Content.hasCheckpoint");
+        let result = util_1.BinarySearch.ofDateTimes(timestamp, this.meta.checkpoints);
+        return result >= 0;
+    }
+    addCheckpoint(timestamp) {
+        this.checkDisposed("Content.addCheckpoint");
+        // We always want to add the new checkpoint at the correctly-sorted index.
+        let result = util_1.BinarySearch.ofDateTimes(timestamp, this.meta.checkpoints);
+        if (result >= 0) {
+            // This checkpoint timestamp is already recorded. Don't add it again.
+            return false;
+        }
+        let insertionPoint = -(result + 1);
+        this.checkpoints.insert(insertionPoint, timestamp);
+        return true;
+    }
+    makeCheckpointBody() {
+        this.checkDisposed("Checkpointable.makeCheckpointBody");
+        const body = this.cloneContentBody();
+        if (body && body.meta) {
+            body.meta.is_head = false;
+            body.meta.created_at = util_1.Struct.clone(body.meta.updated_at);
+            body.meta.ref = Content_1.Content.makeContentRef(body.meta.id, body.meta.updated_at.utc_time);
+            if (body.meta.hasOwnProperty('checkpoints')) {
+                delete body.meta.checkpoints;
+            }
+        }
+        return body;
+    }
+    cloneCheckpoints() {
+        this.checkDisposed("Checkpointable.cloneCheckpoints");
+        if (this.meta.checkpoints) {
+            return util_1.Struct.clone(this.meta.checkpoints);
+        }
+        else {
+            return null;
+        }
+    }
+    recordCheckpoint(checkpointBody) {
+        this.checkDisposed("Checkpointable.recordCheckpoint");
+        // Don't take new checkpoints for timestamps that have already been checkpointed.
+        let checkpointTimestamp = checkpointBody.meta.created_at.utc_time;
+        if (!this.hasCheckpoint(checkpointTimestamp)) {
+            // Record the new checkpoint content
+            const checkpoint = this.shareSync.createContent(checkpointBody);
+            checkpoint.release();
+            // Add a new timestamp entry to the checkpoints array
+            this._checkpointsView.push(checkpointTimestamp);
+        }
+    }
+    async acquireLastCheckpoint() {
+        if (this.meta.checkpoints && this.meta.checkpoints.length > 0) {
+            let checkpoints = this.cloneCheckpoints().sort();
+            const latestCheckpointTimestamp = checkpoints[checkpoints.length - 1];
+            const latestCheckpointRef = Content_1.Content.makeContentRef(this.id, latestCheckpointTimestamp);
+            const checkpoint = await this.shareSync.acquire(this.kind, latestCheckpointRef);
+            return checkpoint;
+        }
+        return null;
+    }
+    async acquireLatestCheckpointAt(timestamp) {
+        let checkpoint = await this.loadLatestCheckpointAt(timestamp);
+        checkpoint = await checkpoint.acquire();
+        return checkpoint;
+    }
+    async loadLatestCheckpointAt(timestamp) {
+        this.checkDisposed("Checkpointable.findLatestCheckpointAt");
+        // To search through checkpoints, we need to make sure we're looking at the HEAD version.
+        if (this.isCheckpoint) {
+            const head = await this.shareSync.acquire(this.kind, this.id);
+            const latestCheckpoint = await head.loadLatestCheckpointAt(timestamp);
+            head.release();
+            return latestCheckpoint;
+        }
+        // First, check to see if the HEAD version of this content might be the "latest checkpoint".
+        if (Time_1.Time.isDateTimeBefore(this.updatedAt.utc_time, timestamp)) {
+            return this;
+        }
+        // The HEAD version is not the latest checkpoint at the given timestamp. Try to find an actual checkpoint.
+        let checkpoints = this.cloneCheckpoints();
+        if (checkpoints) {
+            // Sort the checkpoints array in ascending order (oldest checkpoints are first).
+            checkpoints.sort();
+            // Use binary-search to find this timestamp
+            let idx = util_1.BinarySearch.ofDateTimes(timestamp, checkpoints);
+            // If the resut is negative, then it's an insertion-point...
+            if (idx < 0) {
+                // Convert the result into an insertion point.
+                let insertionPoint = -(idx + 1);
+                // Insertion points always represent the position AFTER the first element that's LESS THAN this element.
+                // So to find the checkpoint that was active at the designated timestamp, we need to find the position
+                // BEFORE this insertion point. But if the insertion point is ZERO, then there is no such checkpoint...
+                if (insertionPoint == 0) {
+                    return null;
+                }
+                idx = insertionPoint - 1;
+            }
+            const checkpointTimestamp = checkpoints[idx];
+            const checkpointRef = Content_1.Content.makeContentRef(this.id, checkpointTimestamp);
+            const checkpoint = await this.shareSync.acquire(this.kind, checkpointRef);
+            return checkpoint;
+        }
+        return this;
+    }
+    async beforeRestoreTo(checkpoint, now) {
+        this.checkDisposed("Checkpointable.beforeRestoreTo");
+        // By default, do nothing. Subclasses can override this behavior, if they choose.
+    }
+    async restoreTo(checkpoint, now) {
+        this.checkDisposed("Checkpointable.restoreTo");
+        if (this.isCheckpoint || checkpoint.kind != this.kind || checkpoint.id !== this.id) {
+            throw new Error(`can't restore checkpoint ${checkpoint.kind}/${checkpoint.ref} into ${this.kind}/${this.ref}`);
+        }
+        // Ensure that the data in the head model has been populated.
+        await this.ensureData();
+        // Call any kind-specific logic preceeding the restoration. For example, a Fragment
+        // might need to restore embedded Comments before restoring the Fragment itself.
+        await this.beforeRestoreTo(checkpoint, now);
+        // We need to make sure the current HEAD state is recorded as a checkpoint. If the most-recent
+        // checkpoint has the same payload as the head, then we can skip recording a new checkpoint.
+        let lastCheckpointPayload = null;
+        const lastCheckpoint = await this.acquireLastCheckpoint();
+        if (lastCheckpoint !== null) {
+            lastCheckpointPayload = lastCheckpoint.payload;
+            lastCheckpoint.release();
+        }
+        if (!util_1.Struct.equals(lastCheckpointPayload, this.payload)) {
+            const checkpointBody = this.makeCheckpointBody();
+            this.recordCheckpoint(checkpointBody);
+        }
+        // Replace the current payload with the payload from the selected checkpoint.
+        let batch = new Operation_1.BatchOperation(this, now);
+        batch.setPathValue(['payload'], util_1.Struct.clone(checkpoint.payload));
+        batch.commit();
+    }
+}
+exports.Checkpointable = Checkpointable;

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

@@ -0,0 +1,19 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { ContentBody, ContentId, ContentMeta, ContentRef } from './Content';
+import { RichText, RichTextPayload } from './RichText';
+export interface CommentPayload extends RichTextPayload {
+    anchor: ContentRef;
+}
+export interface CommentBody extends ContentBody {
+    meta: ContentMeta;
+    payload: CommentPayload;
+}
+export declare class Comment extends RichText {
+    static create(userId: ContentId, anchorContentRef: ContentRef): Comment;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): CommentPayload;
+    get anchor(): ContentRef;
+    setAnchor(value: ContentRef): void;
+}