kindy-editor 1.0.1 → 2.0.0

package/dist/kindy-core.cjs

@@ -0,0 +1,786 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PAGE_STATE: () => DEFAULT_PAGE_STATE,
+  DOCUMENT_ERROR_CODES: () => DOCUMENT_ERROR_CODES,
+  DocumentLibraryClient: () => DocumentLibraryClient,
+  DocumentLibraryError: () => DocumentLibraryError,
+  KINDY_DOCUMENT_SCHEMA_VERSION: () => KINDY_DOCUMENT_SCHEMA_VERSION,
+  MemoryDocumentAdapter: () => MemoryDocumentAdapter,
+  RestDocumentAdapter: () => RestDocumentAdapter,
+  TypedEventEmitter: () => TypedEventEmitter,
+  YjsCollaborationAdapter: () => YjsCollaborationAdapter,
+  cloneDocumentState: () => cloneDocumentState,
+  createDocumentLibrary: () => createDocumentLibrary,
+  createEditorDocumentState: () => createEditorDocumentState,
+  createEmptyDocumentState: () => createEmptyDocumentState,
+  createLegacyCallbackAdapter: () => createLegacyCallbackAdapter,
+  createMemoryDocumentAdapter: () => createMemoryDocumentAdapter,
+  createRestDocumentAdapter: () => createRestDocumentAdapter,
+  createYjsCollaborationAdapter: () => createYjsCollaborationAdapter,
+  migrateDocumentState: () => migrateDocumentState,
+  stateFromEditor: () => stateFromEditor,
+  toCanonicalHeaderFooter: () => toCanonicalHeaderFooter,
+  toCanonicalSection: () => toCanonicalSection,
+  toDocumentLibraryError: () => toDocumentLibraryError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/types.ts
+var KINDY_DOCUMENT_SCHEMA_VERSION = "2.0";
+
+// src/core/errors.ts
+var DOCUMENT_ERROR_CODES = [
+  "DOCX_INVALID",
+  "DOCX_UNSUPPORTED",
+  "IMPORT_FAILED",
+  "EXPORT_FAILED",
+  "ADAPTER_ERROR",
+  "NETWORK_ERROR",
+  "VERSION_CONFLICT",
+  "DOCUMENT_NOT_FOUND",
+  "OPERATION_CANCELLED"
+];
+var DocumentLibraryError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    this.name = "DocumentLibraryError";
+    this.code = code;
+    this.status = options.status;
+    this.details = options.details;
+  }
+};
+function toDocumentLibraryError(error, fallback = "ADAPTER_ERROR") {
+  if (error instanceof DocumentLibraryError) return error;
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new DocumentLibraryError("OPERATION_CANCELLED", "Operation was cancelled.", { cause: error });
+  }
+  const message = error instanceof Error ? error.message : String(error || "Unknown error");
+  return new DocumentLibraryError(fallback, message, { cause: error });
+}
+
+// src/core/state.ts
+var DEFAULT_PAGE_STATE = Object.freeze({
+  size: { width: 21, height: 29.7 },
+  orientation: "portrait",
+  margin: { top: 2.54, right: 2.54, bottom: 2.54, left: 2.54 },
+  background: "#ffffff",
+  header: { enabled: false, text: "" },
+  footer: { enabled: false, text: "" },
+  sections: []
+});
+var emptyDocument = { type: "doc", content: [{ type: "paragraph" }] };
+function cloneDocumentState(value) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+    }
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function createEmptyDocumentState(overrides = {}) {
+  const page = overrides.page || {};
+  return {
+    schemaVersion: KINDY_DOCUMENT_SCHEMA_VERSION,
+    content: cloneDocumentState(overrides.content || emptyDocument),
+    page: {
+      ...cloneDocumentState(DEFAULT_PAGE_STATE),
+      ...page,
+      size: page.size || cloneDocumentState(DEFAULT_PAGE_STATE.size),
+      orientation: page.orientation || DEFAULT_PAGE_STATE.orientation,
+      margin: {
+        ...DEFAULT_PAGE_STATE.margin,
+        ...page.margin || {}
+      }
+    },
+    assets: cloneDocumentState(overrides.assets || [])
+  };
+}
+function migrateDocumentState(input) {
+  if (!input || typeof input !== "object") return createEmptyDocumentState();
+  const value = input;
+  if (value.schemaVersion === KINDY_DOCUMENT_SCHEMA_VERSION && value.content) {
+    return createEmptyDocumentState(value);
+  }
+  if (value.type === "doc") {
+    return createEmptyDocumentState({ content: value });
+  }
+  const legacyDocument = value.document;
+  const legacyContent = value.content || legacyDocument?.content;
+  const content = legacyContent && typeof legacyContent === "object" ? legacyContent : emptyDocument;
+  return createEmptyDocumentState({
+    content,
+    page: value.page || {},
+    assets: Array.isArray(value.assets) ? value.assets : []
+  });
+}
+function stateFromEditor(editor, page) {
+  return createEmptyDocumentState({ content: editor.getJSON(), page });
+}
+
+// src/core/editor-state.ts
+function toCanonicalHeaderFooter(value) {
+  if (!value) return void 0;
+  const first = value.variants?.first || {};
+  const even = value.variants?.even || {};
+  return {
+    enabled: Boolean(value.enable ?? value.enabled),
+    ...value.content ? { content: cloneDocumentState(value.content) } : {},
+    text: value.text || value.leftText || "",
+    ...first.content ? { firstContent: cloneDocumentState(first.content) } : {},
+    firstText: first.text || "",
+    ...even.content ? { evenContent: cloneDocumentState(even.content) } : {},
+    evenText: even.text || "",
+    differentFirstPage: Boolean(value.differentFirstPage),
+    differentOddEven: Boolean(value.differentOddEven)
+  };
+}
+function toCanonicalSection(section, page) {
+  const defaultState = createEmptyDocumentState().page;
+  return {
+    id: section.id || `section-${section.fromBlockId || "default"}`,
+    ...section.fromBlockId ? { fromBlockId: section.fromBlockId } : {},
+    ...Number.isFinite(section.pageNumberStart) ? { pageNumberStart: section.pageNumberStart } : {},
+    size: {
+      width: section.size?.width || page.size?.width || defaultState.size.width,
+      height: section.size?.height || page.size?.height || defaultState.size.height
+    },
+    orientation: section.orientation || page.orientation || defaultState.orientation,
+    margin: {
+      ...defaultState.margin,
+      ...page.margin || {},
+      ...section.margin || {}
+    },
+    ...section.header ? { header: toCanonicalHeaderFooter(section.header) } : {},
+    ...section.footer ? { footer: toCanonicalHeaderFooter(section.footer) } : {}
+  };
+}
+function createEditorDocumentState(input) {
+  const page = input.page || {};
+  return createEmptyDocumentState({
+    content: input.content,
+    assets: cloneDocumentState(input.assets || []),
+    page: {
+      size: page.size?.width && page.size?.height ? { width: page.size.width, height: page.size.height } : void 0,
+      orientation: page.orientation,
+      margin: page.margin,
+      background: page.background,
+      watermark: page.watermark,
+      header: toCanonicalHeaderFooter(page.header),
+      footer: toCanonicalHeaderFooter(page.footer),
+      sections: Array.isArray(page.sections) ? page.sections.map((section) => toCanonicalSection(section, page)) : []
+    }
+  });
+}
+
+// src/core/emitter.ts
+var TypedEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    const listeners = this.listeners.get(event) || /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.listeners.set(event, listeners);
+    return () => listeners.delete(listener);
+  }
+  emit(event, payload) {
+    this.listeners.get(event)?.forEach((listener) => listener(payload));
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/core/client.ts
+var DocumentLibraryClient = class extends TypedEventEmitter {
+  adapter;
+  codecs;
+  engine;
+  locale;
+  theme;
+  autosaveEnabled;
+  autosaveDelay;
+  autosaveTimer = null;
+  saveController = null;
+  savePromise = null;
+  snapshot = null;
+  dirty = false;
+  conflicted = false;
+  mutation = 0;
+  constructor(options) {
+    super();
+    this.adapter = options.adapter;
+    this.codecs = options.codecs;
+    this.engine = options.engine;
+    this.locale = options.locale || "vi-VN";
+    this.theme = options.theme || {};
+    this.autosaveEnabled = options.autosave?.enabled ?? true;
+    this.autosaveDelay = Math.max(250, options.autosave?.delay ?? 3e4);
+  }
+  get current() {
+    return this.snapshot ? cloneDocumentState(this.snapshot) : null;
+  }
+  get hasUnsavedChanges() {
+    return this.dirty;
+  }
+  get hasConflict() {
+    return this.conflicted;
+  }
+  listDocuments(query, signal) {
+    return this.adapter.listDocuments(query, signal);
+  }
+  async open(documentId, versionId, signal) {
+    this.cancelPendingSave();
+    const snapshot = await this.adapter.loadState(documentId, versionId, signal);
+    snapshot.state = migrateDocumentState(snapshot.state);
+    this.snapshot = snapshot;
+    this.dirty = false;
+    this.conflicted = false;
+    const current = this.current;
+    this.emit("opened", current);
+    return current;
+  }
+  async create(input, signal) {
+    const document = await this.adapter.createDocument({ ...input, state: input.state || createEmptyDocumentState() }, signal);
+    return this.open(document.id, void 0, signal);
+  }
+  async import(input, signal) {
+    const document = await this.adapter.importDocument({ ...input, state: migrateDocumentState(input.state) }, signal);
+    this.emit("imported", { document, compatibilityReport: input.compatibilityReport });
+    return this.open(document.id, void 0, signal);
+  }
+  updateState(state) {
+    if (!this.snapshot) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", "Open a document before updating state.");
+    this.snapshot.state = migrateDocumentState(state);
+    this.mutation += 1;
+    this.dirty = true;
+    const current = this.current;
+    this.emit("changed", current);
+    if (this.autosaveEnabled && !this.conflicted) this.scheduleAutosave();
+    return current;
+  }
+  async save(reason = "manual") {
+    if (this.savePromise) {
+      try {
+        await this.savePromise;
+      } catch {
+      }
+    }
+    const operation = this.performSave(reason);
+    this.savePromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (this.savePromise === operation) this.savePromise = null;
+    }
+  }
+  async performSave(reason) {
+    if (!this.snapshot) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", "Open a document before saving.");
+    if (this.conflicted) throw new DocumentLibraryError("VERSION_CONFLICT", "Autosave is paused until the conflict is resolved.");
+    this.cancelPendingSave(false);
+    const controller = new AbortController();
+    this.saveController = controller;
+    const { snapshot } = this;
+    const savedMutation = this.mutation;
+    this.emit("save-started", { documentId: snapshot.document.id, reason });
+    try {
+      const result = await this.adapter.saveState(snapshot.document.id, {
+        state: cloneDocumentState(snapshot.state),
+        baseRevisionId: snapshot.revisionId,
+        reason,
+        clientMutationId: globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random()}`
+      }, controller.signal);
+      snapshot.revisionId = result.revisionId;
+      snapshot.document.currentRevisionId = result.revisionId;
+      if (result.version) {
+        snapshot.version = result.version;
+        snapshot.document.currentVersionId = result.version.id;
+      }
+      this.dirty = savedMutation !== this.mutation;
+      this.emit("saved", { ...result, documentId: snapshot.document.id });
+      if (this.dirty && this.autosaveEnabled) this.scheduleAutosave();
+      return result;
+    } catch (error) {
+      const normalized = toDocumentLibraryError(error);
+      if (normalized.code === "VERSION_CONFLICT") this.conflicted = true;
+      this.emit("save-failed", normalized);
+      this.emit("error", normalized);
+      throw normalized;
+    } finally {
+      if (this.saveController === controller) this.saveController = null;
+    }
+  }
+  async restore(versionId, signal) {
+    if (!this.snapshot) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", "Open a document before restoring a version.");
+    const restored = await this.adapter.restoreVersion(this.snapshot.document.id, versionId, signal);
+    restored.state = migrateDocumentState(restored.state);
+    this.snapshot = restored;
+    this.dirty = false;
+    this.conflicted = false;
+    const current = this.current;
+    this.emit("version-restored", current);
+    return current;
+  }
+  async storeArtifact(input, signal) {
+    if (!this.snapshot) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", "Open a document before storing an artifact.");
+    return this.adapter.storeArtifact(this.snapshot.document.id, input, signal);
+  }
+  resolveConflict(snapshot) {
+    this.snapshot = { ...cloneDocumentState(snapshot), state: migrateDocumentState(snapshot.state) };
+    this.dirty = false;
+    this.conflicted = false;
+  }
+  destroy() {
+    this.cancelPendingSave();
+    this.snapshot = null;
+    this.clear();
+  }
+  scheduleAutosave() {
+    if (this.autosaveTimer) clearTimeout(this.autosaveTimer);
+    this.autosaveTimer = setTimeout(() => {
+      this.autosaveTimer = null;
+      if (this.dirty && !this.conflicted) void this.save("autosave").catch(() => void 0);
+    }, this.autosaveDelay);
+  }
+  cancelPendingSave(abort = true) {
+    if (this.autosaveTimer) clearTimeout(this.autosaveTimer);
+    this.autosaveTimer = null;
+    if (abort) this.saveController?.abort();
+    this.saveController = null;
+  }
+};
+var createDocumentLibrary = (options) => new DocumentLibraryClient(options);
+
+// src/core/collaboration.ts
+var YjsCollaborationAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async connect(context) {
+    const provider = await this.options.providerFactory({ documentId: context.documentId, user: context.user, editor: context.editor });
+    provider.connect?.();
+    return {
+      disconnect() {
+        provider.disconnect?.();
+        provider.destroy?.();
+      },
+      getUsers: () => provider.awareness?.getStates ? [...provider.awareness.getStates().values()] : []
+    };
+  }
+};
+var createYjsCollaborationAdapter = (options) => new YjsCollaborationAdapter(options);
+
+// src/core/adapters/rest.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function queryString(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") return;
+    if (Array.isArray(value)) value.forEach((item) => params.append(key, String(item)));
+    else params.set(key, String(value));
+  });
+  const result = params.toString();
+  return result ? `?${result}` : "";
+}
+var RestDocumentAdapter = class {
+  baseUrl;
+  transport;
+  constructor(options) {
+    if (!options?.baseUrl) throw new TypeError("RestDocumentAdapter requires baseUrl.");
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.transport = options.transport || globalThis.fetch.bind(globalThis);
+  }
+  async request(path, init = {}) {
+    try {
+      const response = await this.transport(`${this.baseUrl}${path}`, init);
+      if (!response.ok) {
+        let details;
+        try {
+          details = await response.json();
+        } catch {
+          details = await response.text();
+        }
+        const code = response.status === 404 ? "DOCUMENT_NOT_FOUND" : response.status === 409 ? "VERSION_CONFLICT" : "ADAPTER_ERROR";
+        throw new DocumentLibraryError(code, `Document API returned ${response.status}.`, {
+          status: response.status,
+          details
+        });
+      }
+      if (response.status === 204) return void 0;
+      return await response.json();
+    } catch (error) {
+      if (error instanceof DocumentLibraryError) throw error;
+      throw toDocumentLibraryError(error, "NETWORK_ERROR");
+    }
+  }
+  json(path, method, body, signal) {
+    return this.request(path, {
+      method,
+      signal,
+      headers: { "content-type": "application/json" },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+  }
+  listDocuments(query, signal) {
+    return this.request(`/documents${queryString(query)}`, { signal });
+  }
+  getDocument(documentId, signal) {
+    return this.request(`/documents/${encodeURIComponent(documentId)}`, { signal });
+  }
+  createDocument(input, signal) {
+    return this.json("/documents", "POST", input, signal);
+  }
+  importDocument(input, signal) {
+    const data = new FormData();
+    data.set("file", input.file, input.fileName || "document.docx");
+    data.set("metadata", JSON.stringify({
+      title: input.title,
+      fileName: input.fileName,
+      folderId: input.folderId,
+      tags: input.tags,
+      metadata: input.metadata
+    }));
+    data.set("state", JSON.stringify(input.state));
+    if (input.compatibilityReport) data.set("compatibilityReport", JSON.stringify(input.compatibilityReport));
+    return this.request("/documents/import", { method: "POST", body: data, signal });
+  }
+  updateDocument(documentId, patch, signal) {
+    return this.json(`/documents/${encodeURIComponent(documentId)}`, "PATCH", patch, signal);
+  }
+  loadState(documentId, versionId, signal) {
+    const suffix = versionId ? `?versionId=${encodeURIComponent(versionId)}` : "";
+    return this.request(`/documents/${encodeURIComponent(documentId)}/state${suffix}`, { signal });
+  }
+  saveState(documentId, input, signal) {
+    return this.json(`/documents/${encodeURIComponent(documentId)}/state`, "PUT", input, signal);
+  }
+  listVersions(documentId, query, signal) {
+    return this.request(
+      `/documents/${encodeURIComponent(documentId)}/versions${queryString(query)}`,
+      { signal }
+    );
+  }
+  restoreVersion(documentId, versionId, signal) {
+    return this.json(
+      `/documents/${encodeURIComponent(documentId)}/versions/${encodeURIComponent(versionId)}/restore`,
+      "POST",
+      void 0,
+      signal
+    );
+  }
+  listFolders(query, signal) {
+    return this.request(`/folders${queryString(query)}`, { signal });
+  }
+  listTemplates(query, signal) {
+    return this.request(`/templates${queryString(query)}`, { signal });
+  }
+  storeArtifact(documentId, input, signal) {
+    const data = new FormData();
+    data.set("file", input.blob, input.fileName);
+    data.set("fileName", input.fileName);
+    data.set("format", input.format);
+    if (input.versionId) data.set("versionId", input.versionId);
+    if (input.compatibilityReport) data.set("compatibilityReport", JSON.stringify(input.compatibilityReport));
+    return this.request(`/documents/${encodeURIComponent(documentId)}/artifacts`, {
+      method: "POST",
+      body: data,
+      signal
+    });
+  }
+  getArtifact(documentId, artifactId, signal) {
+    return this.request(
+      `/documents/${encodeURIComponent(documentId)}/artifacts/${encodeURIComponent(artifactId)}`,
+      { signal }
+    );
+  }
+};
+var createRestDocumentAdapter = (options) => new RestDocumentAdapter(options);
+
+// src/core/adapters/memory.ts
+var id = (prefix) => `${prefix}-${globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var throwIfAborted = (signal) => {
+  if (signal?.aborted) throw new DocumentLibraryError("OPERATION_CANCELLED", "Operation was cancelled.");
+};
+function paginate(items, query = {}) {
+  const page = Math.max(1, query.page || 1);
+  const pageSize = Math.max(1, query.pageSize || 20);
+  return { items: items.slice((page - 1) * pageSize, page * pageSize), total: items.length, page, pageSize };
+}
+function cloneArtifact(value) {
+  const { blob, ...metadata } = value;
+  return { ...cloneDocumentState(metadata), blob };
+}
+var MemoryDocumentAdapter = class {
+  documents = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  versionStates = /* @__PURE__ */ new Map();
+  artifacts = /* @__PURE__ */ new Map();
+  folders;
+  constructor(seed = {}) {
+    this.folders = cloneDocumentState(seed.folders || []);
+    seed.documents?.forEach((snapshot) => this.seed(snapshot));
+  }
+  seed(snapshot) {
+    const value = cloneDocumentState(snapshot);
+    value.state = migrateDocumentState(value.state);
+    this.documents.set(value.document.id, value.document);
+    this.states.set(value.document.id, value);
+    if (value.version) {
+      this.versions.set(value.document.id, [value.version]);
+      this.versionStates.set(value.version.id, value);
+    }
+  }
+  requireDocument(documentId) {
+    const document = this.documents.get(documentId);
+    if (!document) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", `Document ${documentId} was not found.`, { status: 404 });
+    return document;
+  }
+  async listDocuments(query = {}, signal) {
+    throwIfAborted(signal);
+    const search = query.search?.toLocaleLowerCase();
+    let items = [...this.documents.values()].filter((item) => query.templatesOnly ? item.isTemplate : !item.isTemplate);
+    if (search) items = items.filter((item) => `${item.title} ${item.fileName}`.toLocaleLowerCase().includes(search));
+    if (query.folderId !== void 0) items = items.filter((item) => item.folderId === query.folderId);
+    if (query.tags?.length) items = items.filter((item) => query.tags.every((tag) => item.tags?.includes(tag)));
+    items.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return paginate(cloneDocumentState(items), query);
+  }
+  async getDocument(documentId, signal) {
+    throwIfAborted(signal);
+    return cloneDocumentState(this.requireDocument(documentId));
+  }
+  async createDocument(input, signal) {
+    throwIfAborted(signal);
+    const documentId = id("doc");
+    const createdAt = now();
+    const document = {
+      id: documentId,
+      title: input.title,
+      fileName: input.fileName || `${input.title || "Untitled"}.docx`,
+      folderId: input.folderId,
+      tags: input.tags || [],
+      isTemplate: false,
+      currentRevisionId: id("rev"),
+      createdAt,
+      updatedAt: createdAt,
+      metadata: input.metadata,
+      capabilities: { view: true, edit: true, comment: true, review: true, download: true, restore: true, manage: true }
+    };
+    const version = this.makeVersion(document, input.templateId ? "template" : "create");
+    document.currentVersionId = version.id;
+    this.documents.set(document.id, document);
+    const templateState = input.templateId ? this.states.get(input.templateId)?.state : void 0;
+    if (input.templateId && !templateState) throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", `Template ${input.templateId} was not found.`, { status: 404 });
+    const state = input.state || templateState || createEmptyDocumentState();
+    const snapshot = { document, state, revisionId: document.currentRevisionId, version };
+    this.states.set(document.id, cloneDocumentState(snapshot));
+    this.versionStates.set(version.id, cloneDocumentState(snapshot));
+    return cloneDocumentState(document);
+  }
+  async importDocument(input, signal) {
+    throwIfAborted(signal);
+    const document = await this.createDocument({ ...input, state: input.state }, signal);
+    const versions = this.versions.get(document.id) || [];
+    if (versions[0]) versions[0].reason = "import";
+    const original = {
+      format: "original-docx",
+      blob: input.file,
+      fileName: input.fileName || document.fileName,
+      versionId: document.currentVersionId,
+      compatibilityReport: input.compatibilityReport
+    };
+    const artifact = await this.storeArtifact(document.id, original, signal);
+    return this.updateDocument(document.id, {
+      originalSource: {
+        artifactId: artifact.id,
+        revisionId: document.currentRevisionId,
+        format: "original-docx",
+        fileName: artifact.fileName,
+        compatibilityReport: input.compatibilityReport
+      }
+    }, signal);
+  }
+  async updateDocument(documentId, patch, signal) {
+    throwIfAborted(signal);
+    const document = this.requireDocument(documentId);
+    const updated = { ...document, ...cloneDocumentState(patch), id: document.id, updatedAt: now() };
+    this.documents.set(documentId, updated);
+    const snapshot = this.states.get(documentId);
+    if (snapshot) snapshot.document = cloneDocumentState(updated);
+    for (const versionSnapshot of this.versionStates.values()) {
+      if (versionSnapshot.document.id === documentId) versionSnapshot.document = cloneDocumentState(updated);
+    }
+    return cloneDocumentState(updated);
+  }
+  async loadState(documentId, versionId, signal) {
+    throwIfAborted(signal);
+    this.requireDocument(documentId);
+    const snapshot = versionId ? this.versionStates.get(versionId) : this.states.get(documentId);
+    if (!snapshot || snapshot.document.id !== documentId) {
+      throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", `Version ${versionId} was not found.`, { status: 404 });
+    }
+    return cloneDocumentState(snapshot);
+  }
+  async saveState(documentId, input, signal) {
+    throwIfAborted(signal);
+    const document = this.requireDocument(documentId);
+    if (document.currentRevisionId !== input.baseRevisionId) {
+      throw new DocumentLibraryError("VERSION_CONFLICT", "The document has a newer revision.", {
+        status: 409,
+        details: { currentRevisionId: document.currentRevisionId }
+      });
+    }
+    const revisionId = id("rev");
+    document.currentRevisionId = revisionId;
+    document.updatedAt = now();
+    const version = input.reason === "manual" ? this.makeVersion(document, "manual") : void 0;
+    if (version) document.currentVersionId = version.id;
+    const snapshot = {
+      document: cloneDocumentState(document),
+      state: migrateDocumentState(input.state),
+      revisionId,
+      version
+    };
+    this.states.set(documentId, snapshot);
+    if (version) this.versionStates.set(version.id, cloneDocumentState(snapshot));
+    return { revisionId, savedAt: document.updatedAt, version: cloneDocumentState(version) };
+  }
+  async listVersions(documentId, query = {}, signal) {
+    throwIfAborted(signal);
+    this.requireDocument(documentId);
+    return paginate(cloneDocumentState(this.versions.get(documentId) || []).reverse(), query);
+  }
+  async restoreVersion(documentId, versionId, signal) {
+    throwIfAborted(signal);
+    const source = await this.loadState(documentId, versionId, signal);
+    const document = this.requireDocument(documentId);
+    const revisionId = id("rev");
+    document.currentRevisionId = revisionId;
+    document.updatedAt = now();
+    const version = this.makeVersion(document, "restore");
+    document.currentVersionId = version.id;
+    const snapshot = { document: cloneDocumentState(document), state: source.state, revisionId, version };
+    this.states.set(documentId, cloneDocumentState(snapshot));
+    this.versionStates.set(version.id, cloneDocumentState(snapshot));
+    return cloneDocumentState(snapshot);
+  }
+  async listFolders(_query, signal) {
+    throwIfAborted(signal);
+    return cloneDocumentState(this.folders);
+  }
+  async listTemplates(query = {}, signal) {
+    return this.listDocuments({ ...query, templatesOnly: true }, signal);
+  }
+  async storeArtifact(documentId, input, signal) {
+    throwIfAborted(signal);
+    this.requireDocument(documentId);
+    const artifact = {
+      id: id("artifact"),
+      documentId,
+      versionId: input.versionId,
+      format: input.format,
+      fileName: input.fileName,
+      mimeType: input.blob.type || "application/octet-stream",
+      size: input.blob.size,
+      blob: input.blob,
+      createdAt: now()
+    };
+    this.artifacts.set(artifact.id, artifact);
+    return cloneArtifact(artifact);
+  }
+  async getArtifact(documentId, artifactId, signal) {
+    throwIfAborted(signal);
+    this.requireDocument(documentId);
+    const artifact = this.artifacts.get(artifactId);
+    if (!artifact || artifact.documentId !== documentId) {
+      throw new DocumentLibraryError("DOCUMENT_NOT_FOUND", `Artifact ${artifactId} was not found.`, { status: 404 });
+    }
+    return cloneArtifact(artifact);
+  }
+  makeVersion(document, reason) {
+    const list = this.versions.get(document.id) || [];
+    const version = {
+      id: id("version"),
+      documentId: document.id,
+      number: list.length + 1,
+      revisionId: document.currentRevisionId,
+      reason,
+      createdAt: now()
+    };
+    list.push(version);
+    this.versions.set(document.id, list);
+    return version;
+  }
+};
+var createMemoryDocumentAdapter = (seed) => new MemoryDocumentAdapter(seed);
+
+// src/core/adapters/legacy.ts
+function createLegacyCallbackAdapter(options = {}) {
+  const memory = createMemoryDocumentAdapter();
+  return new Proxy(memory, {
+    get(target, property, receiver) {
+      if (property === "saveState") {
+        return async (documentId, input) => {
+          const result = await target.saveState(documentId, input);
+          await options.onSave?.({ json: input.state.content, state: input.state }, input.state.page);
+          return result;
+        };
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PAGE_STATE,
+  DOCUMENT_ERROR_CODES,
+  DocumentLibraryClient,
+  DocumentLibraryError,
+  KINDY_DOCUMENT_SCHEMA_VERSION,
+  MemoryDocumentAdapter,
+  RestDocumentAdapter,
+  TypedEventEmitter,
+  YjsCollaborationAdapter,
+  cloneDocumentState,
+  createDocumentLibrary,
+  createEditorDocumentState,
+  createEmptyDocumentState,
+  createLegacyCallbackAdapter,
+  createMemoryDocumentAdapter,
+  createRestDocumentAdapter,
+  createYjsCollaborationAdapter,
+  migrateDocumentState,
+  stateFromEditor,
+  toCanonicalHeaderFooter,
+  toCanonicalSection,
+  toDocumentLibraryError
+});