@inshapardaz/likhari-converters 0.1.0

package/dist/html/index.d.ts

@@ -0,0 +1,8 @@
+import type { FormatConverter } from '../types.js';
+/**
+ * Placeholder — HTML import/export is Phase 2 work (lexical-editor-spec.md
+ * §13). Registered now so FormatRegistry's shape is stable and callers get a
+ * clear error instead of a missing format.
+ */
+export declare const htmlConverter: FormatConverter;
+//# sourceMappingURL=index.d.ts.map

package/dist/html/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/html/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,eAQ3B,CAAC"}

package/dist/html/index.js

@@ -0,0 +1,14 @@
+/**
+ * Placeholder — HTML import/export is Phase 2 work (lexical-editor-spec.md
+ * §13). Registered now so FormatRegistry's shape is stable and callers get a
+ * clear error instead of a missing format.
+ */
+export const htmlConverter = {
+    id: 'html',
+    serialize() {
+        throw new Error('@inshapardaz/likhari-converters: HTML export is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §13).');
+    },
+    parse() {
+        throw new Error('@inshapardaz/likhari-converters: HTML import is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §13).');
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './registry.js';
+export { plainTextConverter } from './plain-text/index.js';
+export { lexicalJsonConverter } from './lexical-json/index.js';
+export { markdownConverter } from './markdown/index.js';
+export { htmlConverter } from './html/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './registry.js';
+export { plainTextConverter } from './plain-text/index.js';
+export { lexicalJsonConverter } from './lexical-json/index.js';
+export { markdownConverter } from './markdown/index.js';
+export { htmlConverter } from './html/index.js';

package/dist/lexical-json/index.d.ts

@@ -0,0 +1,8 @@
+import type { FormatConverter } from '../types.js';
+/**
+ * The native/lossless format — the only one that round-trips 100% of state
+ * (custom nodes, exact attributes). Used for autosave and internal storage
+ * (lexical-editor-spec.md §2).
+ */
+export declare const lexicalJsonConverter: FormatConverter;
+//# sourceMappingURL=index.d.ts.map

package/dist/lexical-json/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lexical-json/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAUlC,CAAC"}

package/dist/lexical-json/index.js

@@ -0,0 +1,14 @@
+/**
+ * The native/lossless format — the only one that round-trips 100% of state
+ * (custom nodes, exact attributes). Used for autosave and internal storage
+ * (lexical-editor-spec.md §2).
+ */
+export const lexicalJsonConverter = {
+    id: 'lexical-json',
+    serialize(editorState) {
+        return JSON.stringify(editorState);
+    },
+    parse(input) {
+        return JSON.parse(input);
+    },
+};

package/dist/markdown/index.d.ts

@@ -0,0 +1,9 @@
+import type { FormatConverter } from '../types.js';
+/**
+ * Placeholder — the extended Markdown dialect (lexical-editor-spec.md §2.1)
+ * is Phase 2 work (§13) and needs its own spec doc + sign-off before the
+ * converter is built against it. Registered now so FormatRegistry's shape
+ * is stable and callers get a clear error instead of a missing format.
+ */
+export declare const markdownConverter: FormatConverter;
+//# sourceMappingURL=index.d.ts.map

package/dist/markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAY/B,CAAC"}

package/dist/markdown/index.js

@@ -0,0 +1,15 @@
+/**
+ * Placeholder — the extended Markdown dialect (lexical-editor-spec.md §2.1)
+ * is Phase 2 work (§13) and needs its own spec doc + sign-off before the
+ * converter is built against it. Registered now so FormatRegistry's shape
+ * is stable and callers get a clear error instead of a missing format.
+ */
+export const markdownConverter = {
+    id: 'markdown',
+    serialize() {
+        throw new Error('@inshapardaz/likhari-converters: the extended Markdown dialect is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §2.1 and §13).');
+    },
+    parse() {
+        throw new Error('@inshapardaz/likhari-converters: the extended Markdown dialect is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §2.1 and §13).');
+    },
+};

package/dist/plain-text/index.d.ts

@@ -0,0 +1,3 @@
+import type { FormatConverter } from '../types.js';
+export declare const plainTextConverter: FormatConverter;
+//# sourceMappingURL=index.d.ts.map

package/dist/plain-text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plain-text/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAkDhD,eAAO,MAAM,kBAAkB,EAAE,eAkDhC,CAAC"}

package/dist/plain-text/index.js

@@ -0,0 +1,81 @@
+const LIST_ITEM_PREFIX = {
+    bullet: () => '- ',
+    number: (index) => `${index + 1}. `,
+    check: () => '- ',
+};
+/**
+ * Walks a SerializedEditorState tree and produces its plain-text projection.
+ * Per the fidelity matrix (lexical-editor-spec.md §2.2), plain text strips
+ * all formatting — this is a documented, exhaustive mapping per node type,
+ * not an ad hoc `.textContent` walk.
+ */
+function nodeToText(node, listItemIndex = 0) {
+    const withChildren = node;
+    if (node.type === 'text' || node.type === 'linebreak') {
+        return node.text ?? (node.type === 'linebreak' ? '\n' : '');
+    }
+    if (node.type === 'list' && withChildren.children) {
+        const listType = node.listType ?? 'bullet';
+        return withChildren.children
+            .map((child, i) => {
+            const prefix = LIST_ITEM_PREFIX[listType]?.(i) ?? '- ';
+            return prefix + nodeToText(child, i);
+        })
+            .join('\n');
+    }
+    if (withChildren.children) {
+        return withChildren.children.map((child) => nodeToText(child, listItemIndex)).join('');
+    }
+    return '';
+}
+function blockToText(node) {
+    return nodeToText(node);
+}
+export const plainTextConverter = {
+    id: 'plain-text',
+    serialize(editorState) {
+        const root = editorState.root;
+        const blocks = (root.children ?? []).map(blockToText);
+        return blocks.join('\n\n');
+    },
+    parse(input) {
+        const paragraphs = input.split(/\r?\n\r?\n/);
+        const children = paragraphs.map((paragraph) => ({
+            type: 'paragraph',
+            children: paragraph
+                ? [
+                    {
+                        type: 'text',
+                        text: paragraph.replace(/\r?\n/g, '\n'),
+                        detail: 0,
+                        format: 0,
+                        mode: 'normal',
+                        style: '',
+                        version: 1,
+                    },
+                ]
+                : [],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1,
+        }));
+        return {
+            root: {
+                type: 'root',
+                children: children.length > 0 ? children : [{
+                        type: 'paragraph',
+                        children: [],
+                        direction: 'ltr',
+                        format: '',
+                        indent: 0,
+                        version: 1,
+                    }],
+                direction: 'ltr',
+                format: '',
+                indent: 0,
+                version: 1,
+            },
+        };
+    },
+};

package/dist/plain-text/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plain-text/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/plain-text/index.test.ts"],"names":[],"mappings":""}

package/dist/plain-text/index.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { plainTextConverter } from './index.js';
+import { lexicalJsonConverter } from '../lexical-json/index.js';
+describe('plainTextConverter', () => {
+    it('joins paragraph blocks with a blank line', () => {
+        const state = plainTextConverter.parse('Hello world\n\nSecond paragraph');
+        const text = plainTextConverter.serialize(state);
+        expect(text).toBe('Hello world\n\nSecond paragraph');
+    });
+    it('round-trips through lexical-json unchanged', () => {
+        const state = plainTextConverter.parse('One\n\nTwo\n\nThree');
+        const json = lexicalJsonConverter.serialize(state);
+        const restored = lexicalJsonConverter.parse(json);
+        expect(plainTextConverter.serialize(restored)).toBe('One\n\nTwo\n\nThree');
+    });
+    it('produces a single empty paragraph for empty input', () => {
+        const state = plainTextConverter.parse('');
+        expect(state.root.children).toHaveLength(1);
+        expect(plainTextConverter.serialize(state)).toBe('');
+    });
+});

package/dist/registry.d.ts

@@ -0,0 +1,15 @@
+import type { FormatConverter, FormatId, ConverterContext } from './types.js';
+/**
+ * Maps every FormatId to its converter pair (architecture doc §8). The
+ * public API's getContent(format)/setContent(str, format) is a thin dispatch
+ * over this — adding a future format doesn't touch the editor component.
+ */
+export declare class FormatRegistry {
+    private readonly converters;
+    constructor(converters: FormatConverter[]);
+    get(format: FormatId): FormatConverter;
+    serialize(format: FormatId, editorState: Parameters<FormatConverter['serialize']>[0], ctx?: ConverterContext): string;
+    parse(format: FormatId, input: string, ctx?: ConverterContext): import("lexical").SerializedEditorState<import("lexical").SerializedLexicalNode>;
+}
+export declare const defaultFormatRegistry: FormatRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAM3E;;;;GAIG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;gBAEvD,UAAU,EAAE,eAAe,EAAE;IAMzC,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe;IAQtC,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAIrH,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB;CAG9D;AAED,eAAO,MAAM,qBAAqB,gBAKhC,CAAC"}

package/dist/registry.js

@@ -0,0 +1,36 @@
+import { plainTextConverter } from './plain-text/index.js';
+import { lexicalJsonConverter } from './lexical-json/index.js';
+import { markdownConverter } from './markdown/index.js';
+import { htmlConverter } from './html/index.js';
+/**
+ * Maps every FormatId to its converter pair (architecture doc §8). The
+ * public API's getContent(format)/setContent(str, format) is a thin dispatch
+ * over this — adding a future format doesn't touch the editor component.
+ */
+export class FormatRegistry {
+    constructor(converters) {
+        this.converters = new Map();
+        for (const converter of converters) {
+            this.converters.set(converter.id, converter);
+        }
+    }
+    get(format) {
+        const converter = this.converters.get(format);
+        if (!converter) {
+            throw new Error(`@inshapardaz/likhari-converters: no converter registered for format "${format}".`);
+        }
+        return converter;
+    }
+    serialize(format, editorState, ctx) {
+        return this.get(format).serialize(editorState, ctx);
+    }
+    parse(format, input, ctx) {
+        return this.get(format).parse(input, ctx);
+    }
+}
+export const defaultFormatRegistry = new FormatRegistry([
+    plainTextConverter,
+    lexicalJsonConverter,
+    markdownConverter,
+    htmlConverter,
+]);

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import type { SerializedEditorState } from 'lexical';
+/** editor-architecture-design.md §8 / §9 — the four interchange formats. */
+export type FormatId = 'markdown' | 'html' | 'plain-text' | 'lexical-json';
+/**
+ * Carries cross-cutting data a converter may need beyond the EditorState tree
+ * itself — the out-of-band footnote registry (architecture doc §3.3) and a
+ * host-supplied image URL resolver — without coupling converters to the
+ * editor or React.
+ */
+export interface ConverterContext {
+    footnoteRegistry?: Record<string, string>;
+    resolveImageUrl?: (src: string) => string;
+}
+export interface FormatConverter {
+    readonly id: FormatId;
+    serialize(editorState: SerializedEditorState, ctx?: ConverterContext): string;
+    parse(input: string, ctx?: ConverterContext): SerializedEditorState;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,cAAc,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,SAAS,CAAC,WAAW,EAAE,qBAAqB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IAC9E,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,CAAC;CACrE"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@inshapardaz/likhari-converters",
+  "version": "0.1.0",
+  "description": "Format transformers (Markdown/HTML/plain-text/Lexical JSON) against the canonical Lexical EditorState, isolated from UI.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/inshapardaz/likhari"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/fix-esm-extensions.mjs ./dist",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "lexical": "^0.20.0"
+  }
+}