@xenosystem/blocks 0.19.2 → 0.21.0

package/dist/docs/index.js

@@ -0,0 +1,395 @@
+import {
+  Callout,
+  DOCUMENT_FORMAT_COMMANDS,
+  DOCUMENT_TOOLBAR,
+  DocumentController,
+  PageBreak,
+  SafeImage,
+  ToggleBlock,
+  WikiLinkMark,
+  createDocumentExtensions,
+  editorHandle,
+  mountDocumentSurface,
+  runFormat
+} from "../chunk-5VOA3OSG.js";
+import {
+  DOCUMENT_MARK_TYPES,
+  DOCUMENT_NODE_TYPES,
+  LIMITS,
+  SAFE_IMAGE,
+  SAFE_LINK,
+  XDOC_EXTENSION,
+  XDOC_FORMAT,
+  XDOC_VERSION,
+  XdocError,
+  documentToMarkdown,
+  emptyContent,
+  markdownToDocument,
+  nodeTypesIn,
+  pageLinksIn,
+  parseXdoc,
+  plainText,
+  serializeXdoc,
+  validateContent,
+  wordCount
+} from "../chunk-NFOBZJDF.js";
+import "../chunk-2KG3PWR4.js";
+
+// src/docs/document/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { bindConfig } from "@xenosystem/block-sdk";
+
+// src/docs/document/manifest.ts
+var DOCUMENT_PANEL_ID = "xeno.core.document";
+var documentManifest = {
+  id: DOCUMENT_PANEL_ID,
+  version: "0.1.0",
+  title: "Document",
+  icon: "file-text",
+  description: "XENO Docs\u2019 editor over the shared .xdoc format: rich text, lists, tasks, tables, callouts, toggles, page links. The host stores and loads; the block edits and asks. A document containing a block this schema does not know opens read-only, never coerced.",
+  defaultSlot: "center",
+  inputs: [
+    {
+      id: "document",
+      name: "Document",
+      type: "object",
+      description: "{id, versionId?, title, xdoc | content, readOnly?}. `xdoc` is the stored file (text or parsed); `versionId` is round-tripped as `expectedVersion` on save so a stale save is refused, not merged.",
+      multiple: false
+    },
+    {
+      id: "saved",
+      name: "Saved",
+      type: "object",
+      description: "{versionId} \u2014 the host wrote the version the last `save` asked for.",
+      multiple: false
+    },
+    {
+      id: "status",
+      name: "Status",
+      type: "object",
+      description: '{status: "conflict" | "failed", message?} \u2014 the save did not happen, and why.',
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "save",
+      name: "Save",
+      type: "object",
+      description: "{id, expectedVersion?, title, xdoc, content, text, pageLinks}. An INTENT \u2014 the host writes `xdoc` (already validated against the format) as the next version and answers on `saved` or `status`."
+    },
+    {
+      id: "openPage",
+      name: "Open page",
+      type: "object",
+      description: "{pageId, pageTitle} \u2014 a page link (the `wikiLink` mark) was followed. The host navigates."
+    },
+    {
+      id: "dirty",
+      name: "Dirty",
+      type: "object",
+      description: "{dirty} \u2014 the document has unsaved changes (true) or was just saved (false)."
+    }
+  ],
+  commands: [
+    {
+      id: "get_document",
+      title: "Get Document",
+      description: "Return {id, title, status, readOnly, dirty, text, wordCount, pageLinks, unsupported}. `status` travels with the text so an empty string is never read as an empty document when it was an unsupported one.",
+      parameters: {}
+    },
+    { id: "set_title", title: "Set Title", description: "Rename the document (unsaved until `save`).", parameters: { title: { type: "string", description: "The new title", required: true } } },
+    { id: "insert_text", title: "Insert Text", description: "Insert plain text at the cursor.", parameters: { text: { type: "string", description: "The text", required: true } } },
+    {
+      id: "format",
+      title: "Format",
+      description: "Apply one format command: paragraph, h1\u2013h3, bold, italic, underline, strike, code, highlight, bulletList, orderedList, taskList, blockquote, codeBlock, callout, toggle, pageBreak, horizontalRule, link (with href), unlink, undo, redo.",
+      parameters: {
+        command: { type: "string", description: "The command", required: true },
+        href: { type: "string", description: "For link: an http(s) or mailto address" }
+      }
+    },
+    {
+      id: "insert_page_link",
+      title: "Link a Page",
+      description: "Insert a link to another document (the `wikiLink` mark) at the cursor.",
+      parameters: {
+        pageId: { type: "string", description: "The linked document\u2019s id", required: true },
+        pageTitle: { type: "string", description: "Its title, shown as the link text", required: true }
+      }
+    },
+    { id: "save", title: "Save", description: "Ask the host to save. Refused while read-only or already saving.", parameters: {} }
+  ],
+  config: [
+    { key: "placeholder", label: "Placeholder", type: "text", defaultValue: "Start writing\u2026", description: "The empty-document hint.", placeholder: "Start writing\u2026" },
+    { key: "showTitle", label: "Show title field", type: "boolean", defaultValue: true, description: "Edit the title in the block. Off when the host owns the title." }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/docs/document/react/DocumentPanelView.tsx
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import { Column, EmptyState, Input, Note, StatusBar, TextButton, Toolbar, ToolbarGroup } from "@xenosystem/components/chrome";
+
+// src/docs/document/declaration.ts
+var STATUS = { empty: "", ready: "", saving: "Saving\u2026", saved: "Saved", conflict: "Someone saved a newer version", failed: "Not saved", unsupported: "Read only" };
+function documentViewState(c, options = {}) {
+  const s = c.getState();
+  const has = s.id !== null;
+  const editable = has && !s.readOnly;
+  const words = wordCount(c.currentContent());
+  const note = s.status === "unsupported" ? `${s.message ?? "This document cannot be edited here."}${s.unsupported.length ? ` Open it in XENO Docs to edit it.` : ""}` : s.status === "failed" || s.status === "conflict" ? s.message ?? STATUS[s.status] : null;
+  return {
+    hasDocument: has,
+    editable,
+    readOnly: has && s.readOnly,
+    title: s.title,
+    titleShown: has && options.showTitle !== false,
+    tools: DOCUMENT_TOOLBAR.map((t) => ({ key: t.command, command: t.command, label: t.label, active: c.isActive(t.command) })),
+    toolsShown: editable,
+    unsupported: s.status === "unsupported",
+    note,
+    canSave: editable && s.status !== "saving",
+    statusLabel: s.dirty && s.status !== "saving" ? "Unsaved changes" : STATUS[s.status] ?? "",
+    wordsLabel: `${words} ${words === 1 ? "word" : "words"}`
+  };
+}
+function applyDocumentUi(c, intent) {
+  switch (intent.kind) {
+    case "format":
+      if (DOCUMENT_FORMAT_COMMANDS.includes(intent.command)) c.format(intent.command);
+      break;
+    case "title":
+      c.setTitle(intent.value);
+      break;
+    case "save":
+      c.save();
+      break;
+  }
+}
+var documentViewManifest = {
+  ...documentManifest,
+  capabilities: [],
+  inputs: [{ id: "view", name: "View state", type: "object", description: "The DocumentViewModel the runtime derives from the controller on every draw." }],
+  outputs: [{ id: "ui", name: "UI intent", type: "object", description: "{ kind, command?, value? } \u2014 applied by the runtime to the controller." }],
+  commands: []
+};
+var EMPTY = { hasDocument: false, editable: false, readOnly: false, title: "", titleShown: false, tools: [], toolsShown: false, unsupported: false, note: null, canSave: false, statusLabel: "", wordsLabel: "0 words" };
+var BEHAVIOURS = {
+  "docs/documentPanelView": (inputs) => inputs.view ?? EMPTY
+};
+var DOCUMENT_RUNTIME_UNITS = ["document/Surface"];
+var text = (b) => ({ component: "text", props: { text: b } });
+var ui = (kind, fields = {}) => ({ emit: "ui", value: { object: { kind: { value: kind }, ...fields } } });
+var DOCUMENT_DECLARATION = {
+  format: "xeno.block@1",
+  manifest: documentViewManifest,
+  behaviour: "docs/documentPanelView",
+  composition: {
+    component: "fragment",
+    children: [
+      { component: "chrome/EmptyState", when: { not: { input: "view.hasDocument" } }, props: { title: { value: "No document open" }, hint: { value: "Choose a document, or start a new one." } } },
+      {
+        component: "chrome/Column",
+        when: { input: "view.hasDocument" },
+        children: [
+          {
+            component: "chrome/Toolbar",
+            when: { input: "view.toolsShown" },
+            props: {
+              left: {
+                node: {
+                  component: "chrome/ToolbarGroup",
+                  children: [
+                    {
+                      component: "chrome/TextButton",
+                      each: { input: "view.tools", key: "key" },
+                      props: { strong: { item: "active" } },
+                      children: [text({ item: "label" })],
+                      on: { onClick: ui("format", { command: { item: "command" } }) }
+                    }
+                  ]
+                }
+              },
+              right: {
+                node: {
+                  component: "chrome/ToolbarGroup",
+                  props: { end: { value: true } },
+                  children: [{ component: "chrome/TextButton", props: { strong: { value: true }, disabled: { not: { input: "view.canSave" } } }, children: [text({ value: "Save" })], on: { onClick: ui("save") } }]
+                }
+              }
+            }
+          },
+          { component: "chrome/Input", when: { input: "view.titleShown" }, props: { value: { input: "view.title" }, label: { value: "Title" }, readOnly: { input: "view.readOnly" } }, on: { onChange: ui("title", { value: { arg: "" } }) } },
+          { component: "chrome/Note", when: { input: "view.note" }, children: [text({ input: "view.note" })] },
+          { component: "document/Surface" },
+          { component: "chrome/StatusBar", props: { left: { input: "view.wordsLabel" }, right: { input: "view.statusLabel" } } }
+        ]
+      }
+    ]
+  }
+};
+
+// src/docs/document/react/DocumentPanelView.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function DocumentSurface({ controller, surface }) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    return mountDocumentSurface(el, controller, surface);
+  }, [controller]);
+  return /* @__PURE__ */ jsx("div", { ref, "data-xeno-document-surface-host": "" });
+}
+var documentRuntimeComponents = (controller, surface) => ({
+  "document/Surface": () => /* @__PURE__ */ jsx(DocumentSurface, { controller, surface })
+});
+function DocumentPanelView({ controller, surface, ...options }) {
+  useSyncExternalStore((fn) => controller.subscribe(fn), () => controller.getState(), () => controller.getState());
+  const view = documentViewState(controller, options);
+  const ui2 = (intent) => applyDocumentUi(controller, intent);
+  if (!view.hasDocument) return /* @__PURE__ */ jsx(EmptyState, { title: "No document open", hint: "Choose a document, or start a new one." });
+  return /* @__PURE__ */ jsxs(Column, { children: [
+    view.toolsShown ? /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsx(ToolbarGroup, { children: view.tools.map((t) => /* @__PURE__ */ jsx(TextButton, { strong: t.active, onClick: () => ui2({ kind: "format", command: t.command }), children: t.label }, t.key)) }),
+        right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx(TextButton, { strong: true, disabled: !view.canSave, onClick: () => ui2({ kind: "save" }), children: "Save" }) })
+      }
+    ) : null,
+    view.titleShown ? /* @__PURE__ */ jsx(Input, { value: view.title, label: "Title", readOnly: view.readOnly, onChange: (value) => ui2({ kind: "title", value }) }) : null,
+    view.note ? /* @__PURE__ */ jsx(Note, { children: view.note }) : null,
+    /* @__PURE__ */ jsx(DocumentSurface, { controller, surface }),
+    /* @__PURE__ */ jsx(StatusBar, { left: view.wordsLabel, right: view.statusLabel })
+  ] });
+}
+
+// src/docs/document/panel.ts
+function createDocumentPanel(options = {}) {
+  return {
+    manifest: documentManifest,
+    activate(host) {
+      const controller = new DocumentController({ host: { emit: (portId, value) => host.emit(portId, value) } });
+      const resolve = (config) => ({
+        showTitle: config.showTitle !== false,
+        placeholder: typeof config.placeholder === "string" ? config.placeholder : "Start writing\u2026"
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot(el);
+        root.render(createElement(DocumentPanelView, { controller, showTitle: renderConfig.showTitle, surface: { placeholder: renderConfig.placeholder, ...options.surface } }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig(host, (config) => {
+        renderConfig = resolve(config);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "document" && value && typeof value === "object") controller.load(value);
+          else if (portId === "saved") controller.saved(value?.versionId);
+          else if (portId === "status") {
+            const p = value;
+            if (p?.status) controller.setStatus(p.status, p.message);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_document":
+              return controller.describe();
+            case "set_title":
+              controller.setTitle(String(params.title ?? ""));
+              return true;
+            case "insert_text":
+              return controller.insertText(String(params.text ?? ""));
+            case "format":
+              return controller.format(String(params.command ?? ""), params.href);
+            case "insert_page_link":
+              return controller.insertPageLink(String(params.pageId ?? ""), String(params.pageTitle ?? ""));
+            case "save":
+              return controller.save();
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var documentPanel = createDocumentPanel();
+export {
+  Callout,
+  BEHAVIOURS as DOCUMENT_BEHAVIOURS,
+  DOCUMENT_DECLARATION,
+  DOCUMENT_FORMAT_COMMANDS,
+  DOCUMENT_MARK_TYPES,
+  DOCUMENT_NODE_TYPES,
+  DOCUMENT_PANEL_ID,
+  DOCUMENT_RUNTIME_UNITS,
+  DOCUMENT_TOOLBAR,
+  DocumentController,
+  DocumentPanelView,
+  DocumentSurface,
+  LIMITS,
+  PageBreak,
+  SAFE_IMAGE,
+  SAFE_LINK,
+  SafeImage,
+  ToggleBlock,
+  WikiLinkMark,
+  XDOC_EXTENSION,
+  XDOC_FORMAT,
+  XDOC_VERSION,
+  XdocError,
+  applyDocumentUi,
+  createDocumentExtensions,
+  createDocumentPanel,
+  documentManifest,
+  documentPanel,
+  documentRuntimeComponents,
+  documentToMarkdown,
+  documentViewManifest,
+  documentViewState,
+  editorHandle,
+  emptyContent,
+  markdownToDocument,
+  mountDocumentSurface,
+  nodeTypesIn,
+  pageLinksIn,
+  parseXdoc,
+  plainText,
+  runFormat,
+  serializeXdoc,
+  validateContent,
+  wordCount
+};