@moloodev/editor-sdk 0.0.0-stage → 0.1.0

package/src/crdt/undo.ts

@@ -0,0 +1,59 @@
+import { LOCAL_ORIGIN, type Doc } from "./doc";
+import { Y } from "./yjs";
+
+const managers = new WeakMap<Doc, Y.UndoManager>();
+
+export type DocUndo = {
+  push: (command?: unknown) => void;
+  undo: () => Promise<boolean>;
+  redo: () => Promise<boolean>;
+  canUndo: () => boolean;
+  canRedo: () => boolean;
+  clear: () => void;
+};
+
+/** Keep the next local change from merging into the current undo item. */
+export function stopCapturing(doc: Doc): void {
+  managers.get(doc)?.stopCapturing();
+}
+
+export function createUndo(doc: Doc): DocUndo {
+  // Hydrated root types are lazy until read. Scope the concrete map before the
+  // first edit so opening undo before an editor projection still captures it.
+  doc.getMap("root");
+  const manager = new Y.UndoManager(doc.getMap("__scope"), {
+    trackedOrigins: new Set([LOCAL_ORIGIN, null]),
+  });
+  managers.set(doc, manager);
+
+  const syncScope = () => {
+    doc.share.forEach((type) => {
+      manager.addToScope(type as never);
+    });
+  };
+  syncScope();
+  doc.on("update", syncScope);
+
+  return {
+    push() {},
+    async undo() {
+      if (manager.undoStack.length === 0) return false;
+      manager.undo();
+      return true;
+    },
+    async redo() {
+      if (manager.redoStack.length === 0) return false;
+      manager.redo();
+      return true;
+    },
+    canUndo() {
+      return manager.undoStack.length > 0;
+    },
+    canRedo() {
+      return manager.redoStack.length > 0;
+    },
+    clear() {
+      manager.clear();
+    },
+  };
+}

package/src/crdt/vite-plugin.ts

@@ -0,0 +1,42 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const yjsEsm = join(dirname(require.resolve("yjs/package.json")), "dist/yjs.mjs");
+
+/**
+ * Server environments must `import("yjs")` through Node so SSR and Nitro
+ * share one evaluation. A file alias beats this and loads a second copy.
+ */
+export const yjsNodeExternals = ["yjs", "y-protocols", "lib0"];
+
+type EnvironmentResolve = {
+  alias?: Record<string, string>;
+  dedupe?: string[];
+  external?: string[];
+};
+
+/**
+ * One Yjs instance per realm. Client: one ESM file. Server: Node's module
+ * cache, shared by every Vite environment in the Nitro worker.
+ */
+export function dedupeYjs(): {
+  name: string;
+  enforce: "post";
+  configEnvironment: (name: string) => { resolve: EnvironmentResolve };
+} {
+  return {
+    name: "moloo-dedupe-yjs",
+    enforce: "post",
+    configEnvironment(name) {
+      if (name === "client") {
+        return {
+          resolve: { alias: { yjs: yjsEsm }, dedupe: ["yjs"] },
+        };
+      }
+      return {
+        resolve: { external: yjsNodeExternals, dedupe: ["yjs"] },
+      };
+    },
+  };
+}

package/src/crdt/yjs.ts

@@ -0,0 +1,16 @@
+/** Sole module that imports `yjs`. Do not re-export this file from the package root. */
+import * as Y from "yjs";
+import { Awareness } from "y-protocols/awareness";
+import * as syncProtocol from "y-protocols/sync";
+import * as awarenessProtocol from "y-protocols/awareness";
+import * as decoding from "lib0/decoding";
+import * as encoding from "lib0/encoding";
+
+export {
+  Y,
+  Awareness,
+  syncProtocol,
+  awarenessProtocol,
+  decoding,
+  encoding,
+};

package/src/editor-common.ts

@@ -0,0 +1,160 @@
+import type { ChromeManifest } from "./protocol";
+
+export const resetLayoutCommandId = "editor.resetLayout";
+
+export const EDITOR_COMMON_CONTRIBUTES = {
+  commands: [
+    {
+      id: "editor.new",
+      title: "새로 만들기...",
+      group: "파일",
+    },
+    {
+      id: "editor.open",
+      title: "열기...",
+      group: "파일",
+    },
+    {
+      id: "editor.import",
+      title: "가져오기...",
+      group: "파일",
+      when: "editorCanImport && editorMode == 'edit' && editorHasAsset",
+    },
+    {
+      id: "editor.download",
+      title: "다운로드...",
+      group: "파일",
+      when: "editorCanDownload && editorHasAsset",
+    },
+    {
+      id: "editor.undo",
+      title: "실행 취소",
+      group: "편집",
+      when: "editorMode == 'edit' && editorCanUndo",
+    },
+    {
+      id: "editor.redo",
+      title: "다시 실행",
+      group: "편집",
+      when: "editorMode == 'edit' && editorCanRedo",
+    },
+    {
+      id: "editor.cut",
+      title: "잘라내기",
+      group: "편집",
+      when: "editorMode == 'edit'",
+    },
+    {
+      id: "editor.copy",
+      title: "복사하기",
+      group: "편집",
+    },
+    {
+      id: "editor.paste",
+      title: "붙여넣기",
+      group: "편집",
+      when: "editorMode == 'edit'",
+    },
+    {
+      id: "editor.delete",
+      title: "삭제하기",
+      group: "편집",
+      when: "editorMode == 'edit'",
+    },
+    {
+      id: "editor.preferences",
+      title: "에디터 설정...",
+      group: "앱",
+    },
+    {
+      id: resetLayoutCommandId,
+      title: "레이아웃 초기화",
+      group: "보기",
+    },
+  ],
+  menus: [
+    {
+      path: ["file", "new"],
+      commandId: "editor.new",
+      group: "1_lifecycle",
+      order: 10,
+    },
+    {
+      path: ["file", "open"],
+      commandId: "editor.open",
+      group: "1_lifecycle",
+      order: 20,
+    },
+    {
+      path: ["file", "import"],
+      commandId: "editor.import",
+      group: "2_io",
+      order: 10,
+      when: "editorCanImport",
+    },
+    {
+      path: ["file", "download"],
+      commandId: "editor.download",
+      group: "2_io",
+      order: 20,
+      when: "editorCanDownload",
+    },
+    {
+      path: ["edit", "undo"],
+      commandId: "editor.undo",
+      group: "1_history",
+      order: 10,
+    },
+    {
+      path: ["edit", "redo"],
+      commandId: "editor.redo",
+      group: "1_history",
+      order: 20,
+    },
+    {
+      path: ["edit", "cut"],
+      commandId: "editor.cut",
+      group: "2_clipboard",
+      order: 10,
+      shortcut: "Mod+X",
+    },
+    {
+      path: ["edit", "copy"],
+      commandId: "editor.copy",
+      group: "2_clipboard",
+      order: 20,
+      shortcut: "Mod+C",
+    },
+    {
+      path: ["edit", "paste"],
+      commandId: "editor.paste",
+      group: "2_clipboard",
+      order: 30,
+      shortcut: "Mod+V",
+    },
+    {
+      path: ["edit", "delete"],
+      commandId: "editor.delete",
+      group: "2_clipboard",
+      order: 40,
+      shortcut: "Backspace",
+    },
+    {
+      path: ["edit", "preferences"],
+      commandId: "editor.preferences",
+      group: "9_settings",
+      order: 20,
+    },
+    {
+      path: ["view", "resetLayout"],
+      commandId: resetLayoutCommandId,
+      group: "z_reset",
+      order: 10,
+    },
+  ],
+  keybindings: [
+    { commandId: "editor.undo", key: "Mod+Z" },
+    { commandId: "editor.redo", key: "Mod+Shift+Z" },
+    { commandId: "editor.delete", key: "Backspace" },
+  ],
+} satisfies NonNullable<ChromeManifest["contributes"]>;

package/src/editor-id.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+
+/**
+ * DNS label used for both halves of `publisher.editor`.
+ * 1–63 characters, lowercase letters, digits, and hyphens.
+ * No leading or trailing hyphen. Positions 3–4 must not be `--` (punycode).
+ */
+const editorLabelSchema = z
+  .string()
+  .regex(/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/)
+  .refine((label) => label.length < 4 || label[2] !== "-" || label[3] !== "-");
+
+export const reservedPublishers: readonly string[] = [
+  "www",
+  "api",
+  "app",
+  "admin",
+  "static",
+  "cdn",
+  "preview",
+  "dev",
+  "localhost",
+  "local",
+  "mail",
+  "moloo",
+];
+
+export type EditorId = {
+  publisher: string;
+  editor: string;
+};
+
+export function isEditorLabel(label: string): boolean {
+  return editorLabelSchema.safeParse(label).success;
+}
+
+/** `firstParty` is the only caller that may use the `moloo` publisher. */
+export function isPublisherName(publisher: string, firstParty: boolean): boolean {
+  if (!isEditorLabel(publisher)) return false;
+  if (publisher === "moloo") return firstParty;
+  return !reservedPublishers.includes(publisher);
+}
+
+export function parseEditorId(
+  id: string,
+  firstParty: boolean,
+): EditorId | undefined {
+  const dot = id.indexOf(".");
+  if (dot < 1 || dot !== id.lastIndexOf(".")) return undefined;
+  const publisher = id.slice(0, dot);
+  const editor = id.slice(dot + 1);
+  if (!isPublisherName(publisher, firstParty) || !isEditorLabel(editor)) {
+    return undefined;
+  }
+  return { publisher, editor };
+}

package/src/frame-attributes.ts

@@ -0,0 +1,9 @@
+export const editorFrameAttributes: {
+  sandbox: "allow-scripts";
+  referrerPolicy: "no-referrer";
+  loading: "eager";
+} = {
+  sandbox: "allow-scripts",
+  referrerPolicy: "no-referrer",
+  loading: "eager",
+};

package/src/index.ts

@@ -0,0 +1,229 @@
+import type {
+  BundleConfirm,
+  Composition,
+  Publication,
+} from "@moloodev/platform";
+import type { PrintDocument } from "./print";
+import type { ChromeManifest } from "./chrome-manifest";
+
+export type Json =
+  | null
+  | boolean
+  | number
+  | string
+  | Json[]
+  | { [key: string]: Json };
+
+export type EditorAsset = {
+  id: string;
+  name: string;
+  type: string;
+  storageMode?: "json" | "text" | "blob";
+  contentType?: string | null;
+  schema?: string | null;
+  path: string;
+  epoch: number;
+  headRevision: number;
+  updatedAt: string;
+  contentBytes: number;
+  locked: boolean;
+  lockHeld: boolean;
+  trashed: boolean;
+};
+
+export type EditorAccess = {
+  canManage: boolean;
+};
+
+export type EditorSessionAsset = {
+  id: string;
+  type: string;
+  name: string;
+  storageMode?: "json" | "text" | "blob";
+  contentType?: string | null;
+  schema?: string | null;
+};
+
+export type EditorSession = {
+  asset: EditorSessionAsset | null;
+  mode: "idle" | "loading" | "read" | "edit";
+  data: { [key: string]: Json } | null;
+  syncStatus: "live" | "pending" | "offline" | "error";
+};
+
+export type EditorRevision = {
+  id: string;
+  assetId: string;
+  revision: number;
+  message: string;
+  contentBytes: number;
+  createdAt: string;
+};
+
+type Empty = Record<string, never>;
+
+export type EditorLayoutValues = {
+  panels: {
+    [elementKey: string]: { visible: boolean; size?: number | `${number}%` };
+  };
+  collapsed?: {
+    [sectionId: string]: boolean;
+  };
+};
+
+export type EditorOperation = {
+  "asset.rename": {
+    body: { name: string };
+    success: { name: string };
+  };
+  "layout.load": {
+    body: Empty;
+    success: { layout: EditorLayoutValues | null };
+  };
+  "layout.save": {
+    body: { layout: EditorLayoutValues };
+    success: Empty;
+  };
+  "asset.read": {
+    body: { id: string };
+    /** Snapshot; fileUrl is a bounded base64 data URL for blobs, otherwise null. */
+    success: { asset: EditorAsset; payload: { [key: string]: Json }; fileUrl: string | null };
+  };
+  "asset.list": {
+    body: { type?: string };
+    success: EditorAsset[];
+  };
+  "asset.listRevisions": {
+    body: { id: string };
+    success: EditorRevision[];
+  };
+  "asset.getComposition": {
+    body: { id: string };
+    success: Composition;
+  };
+  "asset.getPublication": {
+    body: { id: string };
+    success: Publication;
+  };
+  "asset.confirmBundle": {
+    body: { id: string; message: string; reviewed: string };
+    success: BundleConfirm;
+  };
+  "asset.putPublication": {
+    body: { id: string; publication: Publication };
+    success: Publication;
+  };
+  "host.pick": {
+    body: {
+      acceptedTypes?: string[];
+      excludeTypes?: string[];
+      excludeIds?: string[];
+    };
+    success:
+      | { cancelled: false; assets: EditorAsset[] }
+      | { cancelled: true };
+  };
+  "host.openAsset": {
+    body: { id: string; type: string };
+    success: Empty;
+  };
+  "host.openInfo": {
+    body: { id: string };
+    success: Empty;
+  };
+  "host.start": {
+    body: Empty;
+    success: Empty;
+  };
+  "host.openBrowser": {
+    body: { excludeIds?: readonly string[] };
+    success: Empty;
+  };
+  "host.clipboardWrite": {
+    body: { text: string };
+    success: Empty;
+  };
+  "host.download": {
+    body:
+      | {
+          filename: string;
+          mimeType: string;
+          content: { kind: "text"; text: string } | { kind: "base64"; data: string };
+        }
+      | { url: string };
+    success: Empty;
+  };
+  "host.openPopup": {
+    body: { url: string };
+    success: Empty;
+  };
+  "host.render": {
+    body: {
+      format: "pdf";
+      document: PrintDocument;
+      name: string;
+    };
+    success: { url: string };
+  };
+  "doc.append": {
+    body: { assetId: string; update: string };
+    success: Empty;
+  };
+  "chrome.submit": {
+    body: ChromeManifest;
+    success: Empty;
+  };
+};
+
+export type EditorRequestType = keyof EditorOperation;
+
+export type EditorRequest = {
+  [Type in EditorRequestType]: {
+    v: 1;
+    id: string;
+    type: Type;
+    body: EditorOperation[Type]["body"];
+  };
+}[EditorRequestType];
+
+export type EditorSuccess<Type extends EditorRequestType = EditorRequestType> =
+  {
+    [T in Type]: {
+      v: 1;
+      id: string;
+      ok: true;
+      body: EditorOperation[T]["success"];
+    };
+  }[Type];
+
+export type EditorFailure = {
+  v: 1;
+  id: string;
+  ok: false;
+  code: string;
+};
+
+export type EditorResponse<Type extends EditorRequestType = EditorRequestType> =
+  | EditorSuccess<Type>
+  | EditorFailure;
+
+export type EditorEvent =
+  | { v: 1; type: "file.import"; body: { name: string; data: string } }
+  | { v: 1; type: "session"; body: EditorSession }
+  | { v: 1; type: "access"; body: EditorAccess }
+  | { v: 1; type: "theme"; body: { theme: "dark" | "light" } }
+  | { v: 1; type: "doc.update"; body: { assetId: string; update: string } }
+  | { v: 1; type: "host.createRequested" }
+  | { v: 1; type: "command.invoke"; body: { commandId: string } }
+  | { v: 1; type: "command.shortcut"; body: { key: string; commandId: string } }
+  | {
+      v: 1;
+      type: "command.state";
+      body: {
+        id: string;
+        visible: boolean;
+        disabled: boolean;
+        pressed: boolean;
+        label: string;
+      };
+    };

package/src/json-schema.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import type { Json } from "./index";
+
+export const jsonSchema: z.ZodType<Json> = z.lazy(() =>
+  z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(jsonSchema),
+    z.record(z.string(), jsonSchema),
+  ]),
+);

package/src/layout/bind-toolbar.ts

@@ -0,0 +1,60 @@
+import type { Spec } from "@json-render/core";
+import type { LayoutElement } from "./types";
+
+const STATE_PROPS = ["disabled", "pressed", "label"] as const;
+
+function commandState(path: string) {
+  return { $state: path };
+}
+
+function elementsOf(spec: Spec): Record<string, LayoutElement> {
+  return spec.elements as Record<string, LayoutElement>;
+}
+
+/** Fill compact ToolbarButton entries with executeCommand + $state bindings. */
+export function bindToolbarSpec(spec: Spec): Spec {
+  const next: Spec = {
+    ...spec,
+    elements: { ...spec.elements },
+  };
+  const elements = elementsOf(next);
+
+  for (const [key, element] of Object.entries(elements)) {
+    if (element.type !== "ToolbarButton") continue;
+    const commandId = String(element.props.commandId ?? "");
+    if (!commandId) continue;
+
+    const bound: LayoutElement = {
+      ...element,
+      props: { ...element.props },
+    };
+    const on = { ...(element.on ?? {}) };
+    if (on.press == null) {
+      bound.on = {
+        ...on,
+        press: { action: "executeCommand", params: { commandId } },
+      };
+    }
+    if (bound.visible == null) {
+      bound.visible = commandState(`/commands/${commandId}/visible`);
+    }
+    for (const prop of STATE_PROPS) {
+      if (bound.props[prop] == null) {
+        bound.props[prop] = commandState(`/commands/${commandId}/${prop}`);
+      }
+    }
+    elements[key] = bound;
+  }
+
+  for (const [key, element] of Object.entries(elements)) {
+    if (element.type !== "Toolbar" || element.visible != null) continue;
+    const conditions = (element.children ?? []).flatMap((childKey) => {
+      const child = elements[childKey];
+      return child?.type === "ToolbarButton" ? [child.visible ?? true] : [];
+    });
+    if (conditions.length === 0) continue;
+    elements[key] = { ...element, visible: { $or: conditions } };
+  }
+
+  return next;
+}