@kodaeditor/core 1.0.3 → 1.0.5

package/LICENSE.md

@@ -1,10 +1,4 @@
-# KodaEditor — Commercial License (DRAFT)
-
-> **Status: draft, prepared ahead of public npm publish — has not had a
-> legal review yet.** Placeholder good enough to make `npm pack`/`npm
-> publish` metadata accurate during Phase 1 preparation (see
-> `docs/LAUNCH-ROADMAP_2026-09-01.md`). Get this reviewed by a lawyer
-> before the packages are actually published to the public npm registry.
+# KodaEditor - Commercial License
 
 Copyright © the KodaEditor authors. All rights reserved except as
 explicitly granted below.
@@ -39,7 +33,7 @@ You may not:
 - Remove copyright or attribution notices from the Software's source.
 
 You may freely use the Software's *output* (the HTML/content your users
-create with it) with no restriction — this license covers the editor
+create with it) with no restriction - this license covers the editor
 itself, not the documents people write in it.
 
 ## 5. Ownership
@@ -80,4 +74,4 @@ issued for it.
 ---
 
 Third-party components bundled inside `@kodaeditor/core` are used under
-their own licenses — see `packages/core/THIRD-PARTY-LICENSES.txt`.
+their own licenses - see `packages/core/THIRD-PARTY-LICENSES.txt`.

package/README.md

@@ -11,17 +11,17 @@ Paste a table from Microsoft Word and it stays a table. Paste a range from Excel
 and it arrives as a real table, not a picture. Paste a page from Google Docs and
 the formatting survives.
 
-That sounds like the baseline every editor claims. It is not: most editors accept
-Word content and quietly flatten it into unstyled paragraphs, and the merged
-cells, column widths, numbered lists and inline colours are gone by the time your
-user notices. Each item below is here because it used to break and was fixed:
+That sounds like a baseline, and it is not: pasted Word content loses its merged
+cells, column widths, numbered lists and inline colours quietly, and the user
+notices only later, in the document they already sent. Each item below is here
+because it used to break in this editor and was fixed:
 
 - numbered and bulleted lists, including nesting levels and lists inside table cells
 - tables with merged cells, column widths and row heights
 - text colour, highlight, bold, italic, underline, strikethrough
 - paragraph alignment, including numbers aligned inside table cells
-- runs of spaces used for layout, which most editors collapse into one
-- images, which most editors drop entirely on a Word paste
+- runs of spaces used for layout, kept instead of collapsed into one
+- images, including the ones Word hides inside drawing shapes
 
 Import is supported directly too: `.docx` (including text inside shapes),
 `.xlsx`, `.csv`, PDF, HTML, Markdown and plain text.
@@ -53,18 +53,47 @@ verified on your own machine.
 No content ever leaves your infrastructure. No account, no tenant, no dashboard
 of ours in the middle.
 
+## Your network is a parameter, not a problem
+
+Locked-down intranet, corporate proxy, a Content Security Policy you cannot
+change, a laptop with no internet at all - these are the deployments the editor
+was built for, not the ones it tolerates.
+
+Rather than bury that in a manual, we made it a questionnaire. Answer five
+questions and get the exact recipe for your case: how to activate the license,
+which files to ship, what to put in your CSP, and which build to take.
+
+**[kodaeditor.com/setup](https://kodaeditor.com/setup)**
+
+Everything it recommends is a shipped capability, not a roadmap item. If your
+combination genuinely does not work, the page says so instead of selling you a
+workaround.
+
 ## Trying it without a licence
 
 Install it and everything works from the first minute. Nothing is switched off,
 nothing is time-limited, there is no signup, and no feature is held back. The
 Word paste is the part worth testing, so we would rather you tested it properly.
 
-Two things mark an unlicensed installation, and neither takes anything away:
+Two things mark an unlicensed installation on a public domain, and neither takes
+anything away:
 
 1. a watermark across the document and a banner above the editor;
 2. one line appended to everything you export - PDF, Word, HTML, Markdown, plain
    text, CSV - saying the file was created in trial mode.
 
+**While you develop, the watermark does not appear.** On localhost, 127.0.0.1
+and the reserved .test and .localhost suffixes the editor runs without it:
+building and evaluating the product is not production use, and we would rather
+you were not looking at a watermark while you decide.
+
+The exported line stays even there - a file you send out is a file you send
+out, wherever it was made.
+
+Note that .local is treated as production, because in company networks it
+usually is - an internal server such as intranet.company.local serves real
+users and needs a license like any other deployment.
+
 Files still open and read normally. There is no limit on size, on how many
 documents you produce, or on which features you use.
 

package/dist/docx-import.d.ts

@@ -1,8 +1,13 @@
+import { type PlaceholderField } from './docx-placeholders';
+export type { PlaceholderField } from './docx-placeholders';
 export interface DocxImportResult {
     html: string;
     warnings: string[];
+    contentWarnings: string[];
+    placeholderFields: PlaceholderField[];
 }
-export type DocxImportErrorCode = 'corrupt' | 'invalid' | 'parse';
+export type DocxImportErrorCode = 'corrupt' | 'invalid' | 'parse' | 'legacy-doc' | 'archive-io';
+export declare function detectContainerKind(buffer: ArrayBuffer): 'zip' | 'ole2' | 'empty' | 'unknown';
 /**
  * An import failure carrying a message fit to show the user
  * (`userMessage`) alongside a machine-readable reason code. Show

package/dist/docx-placeholders.d.ts

@@ -0,0 +1,33 @@
+/** A Word template placeholder turned into a field of the document. */
+export interface PlaceholderField {
+    /**
+     * Stable name for the field. Taken from Word's own `w:tag` when the template
+     * author set one, otherwise derived from the control's internal id.
+     */
+    key: string;
+    /** The text the reader sees - exactly what stood in the Word document. */
+    label: string;
+    /** Word's own caption for the field (`w:alias`), empty when the file has none. */
+    hint: string;
+    /**
+     * Caption WE derived from the text in front of the placeholder («Fax:» before
+     * «[Enter number]»), empty when there was nothing to derive it from. Kept
+     * apart from `hint` on purpose: «Word said so» and «we worked it out» must
+     * stay tellable apart.
+     */
+    context: string;
+    /**
+     * Whether the key survives an edit of the template. `false` means the key
+     * depends on the ORDER of placeholders: inserting a field above shifts it,
+     * and a host that stored «this key is the tax ID» will then put the tax ID
+     * somewhere else, silently.
+     *
+     * What `true` states is narrower than it sounds: the identifier is unique
+     * WITHIN THIS FILE. Whether Word keeps it across a re-save of the template is
+     * not something we have measured.
+     */
+    stable: boolean;
+}
+export declare function markPlaceholdersInDoc(doc: Document): boolean;
+export declare function buildPlaceholderFields(root: HTMLElement): PlaceholderField[];
+export declare function hasPlaceholderMarkup(xml: string): boolean;

package/dist/editor.d.ts

@@ -15,6 +15,15 @@ export interface EditorOptions {
     strings?: Strings;
     /** Called on every change to the document. */
     onChange?: (html: string) => void;
+    onImportError?: (message: string) => void;
+    onImportWarnings?: (warnings: string[]) => void;
+    onUnfilledFields?: (fields: Array<{
+        key: string;
+        label: string;
+        hint: string | null;
+        context: string | null;
+        stable: boolean;
+    }>) => void;
     /** Hooks for the floating table toolbar, so a host can open its own dialog. */
     tableCallbacks?: {
         onSplitCell?: () => void;
@@ -40,6 +49,9 @@ export interface TableProps {
 export declare class Editor {
     readonly view: EditorView;
     private readonly onChange?;
+    private readonly onImportError?;
+    private readonly onImportWarnings?;
+    private readonly onUnfilledFields?;
     private licensed;
     private licenseCheck;
     private readonly strings;
@@ -233,6 +245,19 @@ export declare class Editor {
     insertImage(src: string, alt?: string): void;
     /** Inserts a merge field: an inline chip replaced by a real value later. */
     insertMergeField(key: string, label?: string): void;
+    /**
+     * Merge fields present in the document, in order - including the ones that
+     * came from Word template placeholders. Ask before submitting a form or
+     * exporting: a field still standing here means a blank left unfilled.
+     */
+    getMergeFields(): Array<{
+        key: string;
+        label: string;
+        hint: string | null;
+        context: string | null;
+        stable: boolean;
+    }>;
+    private htmlForExport;
     /**
      * The document's HTML with merge fields expanded to {{key}} placeholders,
      * for systems that substitute values by {{...}} rather than by data

package/dist/external-shims.d.ts

@@ -0,0 +1,54 @@
+// Generated by scripts/add-type-shims.mjs - do not edit.
+//
+// Declarations for libraries bundled into the build. They let type checking
+// pass on your side without installing those libraries yourself.
+
+declare module 'orderedmap' {
+  export default class OrderedMap<T = unknown> {
+    get(key: string): T | undefined;
+    update(key: string, value: T, newKey?: string): OrderedMap<T>;
+    remove(key: string): OrderedMap<T>;
+    addToStart(key: string, value: T): OrderedMap<T>;
+    addToEnd(key: string, value: T): OrderedMap<T>;
+    forEach(fn: (key: string, value: T) => void): void;
+    readonly size: number;
+  }
+}
+
+declare module 'prosemirror-model' {
+  export type NodeSpec = Record<string, unknown>;
+  export type MarkSpec = Record<string, unknown>;
+  export class Schema<N extends string = string, M extends string = string> {
+    readonly nodes: Record<N, unknown>;
+    readonly marks: Record<M, unknown>;
+  }
+  export class Node {
+    readonly type: { name: string };
+    readonly attrs: Record<string, unknown>;
+    readonly childCount: number;
+    readonly textContent: string;
+    toJSON(): unknown;
+  }
+  export class Fragment {
+    readonly size: number;
+  }
+  export class DOMParser {
+    static fromSchema(schema: Schema): DOMParser;
+    parse(dom: globalThis.Node): Node;
+  }
+  export class DOMSerializer {
+    static fromSchema(schema: Schema): DOMSerializer;
+    serializeFragment(fragment: Fragment): DocumentFragment;
+  }
+}
+
+declare module 'prosemirror-view' {
+  import type { Node } from 'prosemirror-model';
+  export class EditorView {
+    readonly dom: HTMLElement;
+    readonly state: { doc: Node; tr: unknown };
+    dispatch(tr: unknown): void;
+    focus(): void;
+    destroy(): void;
+  }
+}

package/dist/i18n.d.ts

@@ -110,6 +110,9 @@ export interface Strings {
     toolbarHint: string;
     trialExportNotice: string;
     importFailed: string;
+    importNothingImported: string;
+    importPartialLoss: string;
+    exportUnfilledFields: string;
     imageTooBig: string;
     imageWrongType: string;
     imageUploadFailed: string;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="./external-shims.d.ts" />
 /**
  * Entry point of @kodaeditor/core.
  *
@@ -6,7 +7,7 @@
  * works out of the box in any framework and in plain HTML.
  */
 export { Editor, type EditorOptions } from './editor';
-export { importDocxToHtml, type DocxImportResult, DocxImportError, classifyDocxError, rawTextToHtml, type DocxImportErrorCode, } from './docx-import';
+export { importDocxToHtml, type DocxImportResult, type PlaceholderField, DocxImportError, classifyDocxError, rawTextToHtml, type DocxImportErrorCode, } from './docx-import';
 export { editorSchema } from './schema';
 export { docToHTML, htmlToDoc } from './serialize';
 export { validateLicense, validateLicenseOffline, type LicenseOptions, type OfflineLicenseOptions, type LicenseResult, type LicenseStatus, } from './license';