@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/blocks/types/embed.d.ts

@@ -0,0 +1,40 @@
+import type { Block, BlockProps } from '../../core/block-document';
+import type { BlockField, BlockTypeDefinition, EmailBlockContext, PageBlockContext } from '../block-type';
+/** Where the host renders one of its forms. Only in a page; the reference is the host's. */
+export declare class FormBlock implements BlockTypeDefinition {
+    readonly type = "form";
+    readonly labelKey = "blocks.form";
+    readonly kinds: readonly ["page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    create(nextId: () => string, props?: BlockProps): Block;
+    page(context: PageBlockContext): string;
+}
+/**
+ * Free HTML written by the author. In a page it is kept as written (balanced by the parser);
+ * in an e-mail it must already follow the e-mail rules and is emitted through `mj-raw`, the
+ * only raw region the compilation accepts, and only from this generator.
+ */
+export declare class HtmlBlock implements BlockTypeDefinition {
+    readonly type = "html";
+    readonly labelKey = "blocks.customHtml";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        padding: {
+            selectors: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}

package/dist/blocks/types/layout.d.ts

@@ -0,0 +1,41 @@
+import type { Block, BlockNodeType, BlockProps } from '../../core/block-document';
+import type { BlockField, BlockTypeDefinition, EmailBlockContext, PageBlockContext } from '../block-type';
+/** Content blocks a column holds. A form only exists in a page (checked by its definition). */
+export declare const COLUMN_CONTENT: readonly BlockNodeType[];
+/** Weight of a column within its section; the shares are the weights over their sum. */
+export declare function columnWeight(block: Block): number;
+/** A band of the piece: one to four real columns, side by side, stacked on small screens. */
+export declare class SectionBlock implements BlockTypeDefinition {
+    readonly type = "section";
+    readonly labelKey = "blocks.section";
+    readonly kinds: readonly ["email", "page"];
+    readonly root = true;
+    readonly childTypes: readonly BlockNodeType[];
+    readonly childCount: {
+        min: number;
+        max: 4;
+    };
+    readonly fields: readonly BlockField[];
+    create(nextId: () => string, props?: BlockProps): Block;
+    /**
+     * Reversed stacking: the columns are written in reverse order and the section lays them out
+     * right to left, so a large screen shows them as authored and a small one stacks them from
+     * the last. MJML keeps the text of each column left to right.
+     */
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}
+export declare class ColumnBlock implements BlockTypeDefinition {
+    readonly type = "column";
+    readonly labelKey = "blocks.column";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: readonly ("text" | "html" | "form" | "section" | "column" | "heading" | "image" | "button" | "divider" | "spacer" | "footer")[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}

package/dist/blocks/types/media.d.ts

@@ -0,0 +1,53 @@
+import type { Block, BlockProps } from '../../core/block-document';
+import type { BlockField, BlockTypeDefinition, EmailBlockContext, PageBlockContext } from '../block-type';
+/**
+ * An image from the media library (`assetId` + `url`) or an address, with its description.
+ * Without an address it is only a placeholder in the preview and nothing in the output.
+ */
+export declare class ImageBlock implements BlockTypeDefinition {
+    readonly type = "image";
+    readonly labelKey = "blocks.image";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly innerSelector = "img";
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        width: {
+            selectors: string[];
+        };
+        padding: {
+            selectors: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}
+/** A call to action. Its colors come from the global button style unless it sets its own. */
+export declare class ButtonBlock implements BlockTypeDefinition {
+    readonly type = "button";
+    readonly labelKey = "blocks.button";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly innerSelector = ".ve-button";
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        fontSize: {
+            selectors: string[];
+        };
+        padding: {
+            selectors: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}

package/dist/blocks/types/structure.d.ts

@@ -0,0 +1,44 @@
+import type { Block, BlockProps } from '../../core/block-document';
+import type { BlockField, BlockTypeDefinition, EmailBlockContext, PageBlockContext } from '../block-type';
+/** A horizontal rule in the global divider style. */
+export declare class DividerBlock implements BlockTypeDefinition {
+    readonly type = "divider";
+    readonly labelKey = "blocks.divider";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly innerSelector = "hr";
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        padding: {
+            selectors: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}
+/** Vertical space. */
+export declare class SpacerBlock implements BlockTypeDefinition {
+    readonly type = "spacer";
+    readonly labelKey = "blocks.spacer";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        height: {
+            selectors: string[];
+            properties: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}

package/dist/blocks/types/text.d.ts

@@ -0,0 +1,88 @@
+import type { Block, BlockProps } from '../../core/block-document';
+import type { BlockField, BlockTypeDefinition, EmailBlockContext, PageBlockContext } from '../block-type';
+/** Paragraphs, lists and quotes in the body typography of the piece. */
+export declare class TextBlock implements BlockTypeDefinition {
+    readonly type = "text";
+    readonly labelKey = "blocks.text";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: Readonly<{
+        fontSize: {
+            selectors: string[];
+        };
+        lineHeight: {
+            selectors: string[];
+        };
+        align: {
+            selectors: string[];
+        };
+        padding: {
+            selectors: string[];
+        };
+    }>;
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}
+export declare const HEADING_LEVELS: readonly ["h1", "h2", "h3"];
+/** A title in the heading typography of the piece, as a real `h1`-`h3`. */
+export declare class HeadingBlock implements BlockTypeDefinition {
+    readonly type = "heading";
+    readonly labelKey = "blocks.heading";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: {
+        fontSize: {
+            selectors: string[];
+        };
+        align: {
+            selectors: string[];
+        };
+        padding: {
+            selectors: string[];
+        };
+    };
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+    private level;
+}
+/** The closing lines of a piece in the footer typography. */
+export declare class FooterBlock implements BlockTypeDefinition {
+    readonly type = "footer";
+    readonly labelKey = "blocks.footer";
+    readonly kinds: readonly ["email", "page"];
+    readonly childTypes: never[];
+    readonly childCount: {
+        min: number;
+        max: number;
+    };
+    readonly fields: readonly BlockField[];
+    readonly mobileEmail: Readonly<{
+        fontSize: {
+            selectors: string[];
+        };
+        lineHeight: {
+            selectors: string[];
+        };
+        align: {
+            selectors: string[];
+        };
+        padding: {
+            selectors: string[];
+        };
+    }>;
+    create(nextId: () => string, props?: BlockProps): Block;
+    email(context: EmailBlockContext): string;
+    page(context: PageBlockContext): string;
+}

package/dist/blocks/values.d.ts

@@ -0,0 +1,64 @@
+import type { BlockPropValue, StyleValue } from '../core/block-document';
+import type { DocumentKind } from '../core/document';
+import type { UrlPurpose } from '../security/url-policy';
+import type { BlockContentGuard } from './content-guard';
+import type { RichTextMode } from '../core/rich-text-markup';
+/** The kind of value a property or a global style holds, and what it may contain. */
+export type ValueSpec = {
+    readonly type: 'color';
+} | {
+    readonly type: 'length';
+    readonly units: readonly ('px' | '%')[];
+    readonly max: number;
+} | {
+    readonly type: 'box';
+} | {
+    readonly type: 'fontFamily';
+} | {
+    readonly type: 'ratio';
+} | {
+    readonly type: 'select';
+    readonly options: readonly string[];
+} | {
+    readonly type: 'integer';
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly type: 'toggle';
+} | {
+    readonly type: 'plain';
+    readonly max: number;
+    readonly pattern?: RegExp;
+} | {
+    readonly type: 'url';
+    readonly purpose: UrlPurpose;
+} | {
+    readonly type: 'richtext';
+    readonly mode: RichTextMode;
+} | {
+    readonly type: 'html';
+};
+/** The font stacks a piece may use: written as they are into CSS and MJML, never typed. */
+export declare const FONT_STACKS: readonly [{
+    readonly value: "Arial, Helvetica, sans-serif";
+    readonly labelKey: "properties.fontSans";
+}, {
+    readonly value: "Georgia, Times New Roman, serif";
+    readonly labelKey: "properties.fontSerif";
+}, {
+    readonly value: "Courier New, Courier, monospace";
+    readonly labelKey: "properties.fontMonospace";
+}];
+/**
+ * Every value that reaches CSS, an MJML attribute or a URL passes one of these patterns: they
+ * have no quote, semicolon, brace or angle bracket, so a value can never end the declaration
+ * or the attribute it is written into.
+ */
+export declare class ValueRules {
+    private readonly content;
+    constructor(content: BlockContentGuard);
+    accepts(spec: ValueSpec, value: BlockPropValue | StyleValue, kind: DocumentKind): boolean;
+    /** What a command stores: texts and HTML in their settled form, other values as given. */
+    normalize(spec: ValueSpec, value: BlockPropValue | StyleValue, kind: DocumentKind): BlockPropValue | undefined;
+    private length;
+}

package/dist/browser.js

@@ -0,0 +1,69 @@
+import { _ as e, b as t, g as n, r, s as i, y as a } from "./identity-CJHb6l9N.js";
+import { i as o, n as s, r as c, u as l } from "./block-controller-RjYGvOcn.js";
+import { C as u, S as d, _ as f, a as p, b as m, c as h, d as g, f as _, g as v, h as y, i as b, l as x, m as S, n as C, o as w, r as T, s as E, t as D, u as O, v as k, x as A, y as j } from "./block-factory-C5oHi4Fm.js";
+import { c as M, i as N, o as P, r as F, s as I, t as L } from "./generated-mjml-CtzE-f3v.js";
+//#region src/compilation/browser-compiler.ts
+var R = class {
+	guard = new N();
+	jobs = /* @__PURE__ */ new Set();
+	disposed = !1;
+	async compile(e) {
+		return this.run(e);
+	}
+	async compileGenerated(e) {
+		if (!(e instanceof L)) throw Error("INVALID_COMPILE_INPUT");
+		return this.run(e.source, e.fragments);
+	}
+	async run(e, t) {
+		if (this.disposed) throw Error("COMPILER_DISPOSED");
+		if (this.guard.source(e, t), this.jobs.size >= F.parallelJobs) throw Error("COMPILER_BUSY");
+		let n = t ? {
+			source: e,
+			fragments: [...t]
+		} : e;
+		return new Promise((e, t) => {
+			let r = new Worker(new URL(
+				/* @vite-ignore */
+				new URL("./assets/browser-worker-D56tNvnb.js", import.meta.url).href,
+				"" + import.meta.url
+			), { type: "module" }), i = () => {
+				clearTimeout(o), r.terminate(), this.jobs.delete(a);
+			}, a = () => {
+				i(), t(/* @__PURE__ */ Error("COMPILER_DISPOSED"));
+			}, o = setTimeout(() => {
+				i(), t(/* @__PURE__ */ Error("COMPILE_TIMEOUT"));
+			}, F.timeoutMs);
+			this.jobs.add(a), r.onmessage = (n) => {
+				try {
+					let t = n.data;
+					if (!t || typeof t != "object" || !("html" in t)) throw Error("COMPILE_FAILED");
+					let r = this.guard.output(t.html);
+					i(), e(r);
+				} catch (e) {
+					i(), t(e);
+				}
+			}, r.onerror = () => {
+				i(), t(/* @__PURE__ */ Error("COMPILE_FAILED"));
+			}, r.postMessage(n);
+		});
+	}
+	dispose() {
+		this.disposed = !0;
+		for (let e of [...this.jobs]) e();
+	}
+};
+//#endregion
+//#region src/composition/browser.ts
+function z(e) {
+	return new j(() => new R()).create(e);
+}
+function B(e) {
+	return new D(() => new R()).create(e);
+}
+function V(e) {
+	return new D(() => new R()).toolkit(e);
+}
+//#endregion
+export { S as BLOCK_DOCUMENT_LIMITS, y as BLOCK_NODE_TYPES, s as BlockChecker, O as BlockContentGuard, T as BlockConversionError, w as BlockDefinitionRegistry, v as BlockDocument, f as BlockDocumentError, k as BlockDocumentSchema, D as BlockEditorFactory, g as BlockEditorSession, p as BlockEmailRenderer, h as BlockMjmlGenerator, E as BlockPageGenerator, C as BlockTemplateCatalog, b as BlockToHtmlConversion, R as BrowserMjmlCompiler, I as ContentPolicy, M as ContentPolicyError, r as CssDocumentCodec, n as DOCUMENT_LIMITS, e as DocumentNodeSchema, a as EditorDocument, t as EditorDocumentSchema, j as EditorFactory, u as EditorSession, x as GLOBAL_STYLE_GROUPS, c as GMAIL_CLIP_BYTES, o as GMAIL_NEAR_CLIP_BYTES, L as GeneratedMjml, A as HtmlDocumentAssembler, P as HtmlDocumentCodec, m as InitialDocumentError, d as PreviewDocument, l as SelectionPreviewRenderer, i as UrlPolicy, B as createBlockEditor, V as createBlockToolkit, z as createEditor, _ as parseAnyDocument };
+
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","names":["import.meta.ROLLDOWN_FILE_URL_TbyMcp1yW5yJVWQ06uiGqg","DocumentNodeSchema","EditorDocumentSchema","DOCUMENT_LIMITS","UrlPolicy","EditorDocument","GMAIL_NEAR_CLIP_BYTES","BlockChecker","GMAIL_CLIP_BYTES","SelectionPreviewRenderer","EditorSession","PreviewDocument","BlockDocumentError","BlockEmailRenderer","InitialDocumentError","BlockMjmlGenerator","BlockEditorSession","parseAnyDocument","BlockDocument","BLOCK_NODE_TYPES","BlockToHtmlConversion","GLOBAL_STYLE_GROUPS","BLOCK_DOCUMENT_LIMITS","BlockTemplateCatalog","BlockDefinitionRegistry","BlockConversionError","BlockPageGenerator","BlockEditorFactory","BlockContentGuard","BlockDocumentSchema","HtmlDocumentAssembler","EditorFactory","ContentPolicyError","CompilationGuard","HtmlDocumentCodec","COMPILE_LIMITS","ContentPolicy","GeneratedMjml","BrowserMjmlCompiler","source","mjml","fragments","request","worker","finish","timer","cancel","reject","message","event","html","resolve","error","createEditor","options","createBlockEditor","createBlockToolkit","CssDocumentCodec"],"sources":["../src/compilation/browser-compiler.ts","../src/composition/browser.ts"],"sourcesContent":["import type { MjmlCompilerPort } from '../renderers/email-renderer';\nimport { CompilationGuard, COMPILE_LIMITS } from './guard';\nimport { GeneratedMjml } from './generated-mjml';\nimport type { CompileRequest, GeneratedMjmlCompilerPort } from './generated-mjml';\n\nexport class BrowserMjmlCompiler implements MjmlCompilerPort, GeneratedMjmlCompilerPort {\n  private readonly guard = new CompilationGuard();\n  private readonly jobs = new Set<() => void>();\n  private disposed = false;\n\n  /** MJML from outside: no raw region is accepted. */\n  async compile(source: string): Promise<string> {\n    return this.run(source);\n  }\n\n  /** MJML of the block codec, with the raw regions it generated. */\n  async compileGenerated(mjml: GeneratedMjml): Promise<string> {\n    if (!(mjml instanceof GeneratedMjml)) throw new Error('INVALID_COMPILE_INPUT');\n    return this.run(mjml.source, mjml.fragments);\n  }\n\n  private async run(source: string, fragments?: readonly string[]): Promise<string> {\n    if (this.disposed) throw new Error('COMPILER_DISPOSED');\n    this.guard.source(source, fragments);\n    if (this.jobs.size >= COMPILE_LIMITS.parallelJobs) throw new Error('COMPILER_BUSY');\n    const request: CompileRequest = fragments ? { source, fragments: [...fragments] } : source;\n    return new Promise<string>((resolve, reject) => {\n      const worker = new Worker(new URL('./browser-worker.ts', import.meta.url), {\n        type: 'module',\n      });\n      const finish = () => {\n        clearTimeout(timer);\n        worker.terminate();\n        this.jobs.delete(cancel);\n      };\n      const cancel = () => {\n        finish();\n        reject(new Error('COMPILER_DISPOSED'));\n      };\n      const timer = setTimeout(() => {\n        finish();\n        reject(new Error('COMPILE_TIMEOUT'));\n      }, COMPILE_LIMITS.timeoutMs);\n      this.jobs.add(cancel);\n      worker.onmessage = (event: MessageEvent<unknown>) => {\n        try {\n          const message = event.data;\n          if (!message || typeof message !== 'object' || !('html' in message))\n            throw new Error('COMPILE_FAILED');\n          const html = this.guard.output(message.html);\n          finish();\n          resolve(html);\n        } catch (error) {\n          finish();\n          reject(error);\n        }\n      };\n      worker.onerror = () => {\n        finish();\n        reject(new Error('COMPILE_FAILED'));\n      };\n      worker.postMessage(request);\n    });\n  }\n\n  dispose(): void {\n    this.disposed = true;\n    for (const cancel of [...this.jobs]) cancel();\n  }\n}\n","import { EditorFactory } from './factory';\nimport type { EditorOptions } from './factory';\nimport { BrowserMjmlCompiler } from '../compilation/browser-compiler';\nimport { BlockEditorFactory } from './block-factory';\nimport type {\n  BlockEditorInstance,\n  BlockEditorOptions,\n  BlockToolkit,\n  BlockToolkitOptions,\n} from './block-factory';\n\nexport function createEditor(options?: EditorOptions) {\n  return new EditorFactory(() => new BrowserMjmlCompiler()).create(options);\n}\n\n/** An editor of a block piece (schema 2), compiling e-mails in a browser worker. */\nexport function createBlockEditor(options?: BlockEditorOptions): BlockEditorInstance {\n  return new BlockEditorFactory(() => new BrowserMjmlCompiler()).create(options);\n}\n\n/** Parse, generate, compile and convert block pieces in the browser, without an editor. */\nexport function createBlockToolkit(options?: BlockToolkitOptions): BlockToolkit {\n  return new BlockEditorFactory(() => new BrowserMjmlCompiler()).toolkit(options);\n}\nexport { EditorFactory, InitialDocumentError } from './factory';\nexport type { EditorOptions, EditorInstance } from './factory';\nexport {\n  EditorDocument,\n  EditorDocumentSchema,\n  DocumentNodeSchema,\n  DOCUMENT_LIMITS,\n} from '../core/document';\nexport type {\n  EditorDocumentData,\n  DocumentNode,\n  Diagnostic,\n  DiagnosticSeverity,\n  DocumentKind,\n  SourceInput,\n} from '../core/document';\nexport { EditorSession } from '../application/session';\nexport type { EditorState } from '../application/session';\nexport type {\n  HostAdapters,\n  StorePort,\n  AssetPort,\n  SlotsPort,\n  AssetReference,\n} from '../application/host';\nexport { ContentPolicy, ContentPolicyError } from '../security/policy';\nexport type { SanitizedDocument } from '../security/policy';\nexport type { ContentInventory, ExternalReference } from '../security/content-inventory';\nexport { HtmlDocumentCodec } from '../codecs/html';\nexport { CssDocumentCodec } from '../codecs/css';\nexport { BrowserMjmlCompiler } from '../compilation/browser-compiler';\nexport { PreviewDocument } from '../renderers/preview-document';\nexport { HtmlDocumentAssembler } from '../renderers/preview-document';\nexport { SelectionPreviewRenderer } from '../renderers/selection-preview';\nexport { UrlPolicy } from '../security/url-policy';\nexport { BlockEditorFactory } from './block-factory';\nexport type {\n  BlockCompiler,\n  BlockEditorInstance,\n  BlockEditorOptions,\n  BlockToolkit,\n  BlockToolkitOptions,\n} from './block-factory';\nexport {\n  BlockDocument,\n  BlockDocumentError,\n  BlockDocumentSchema,\n  BLOCK_DOCUMENT_LIMITS,\n  BLOCK_NODE_TYPES,\n} from '../core/block-document';\nexport type {\n  Block,\n  BlockDocumentData,\n  BlockNodeType,\n  BlockPropValue,\n  BlockProps,\n  BlockTarget,\n  GlobalStyles,\n  StylePatch,\n} from '../core/block-document';\nexport { parseAnyDocument } from '../core/any-document';\nexport type { AnyDocument } from '../core/any-document';\nexport { BlockEditorSession } from '../application/block-session';\nexport type {\n  BlockEditorState,\n  BlockImageChoice,\n  BlockStorePort,\n} from '../application/block-session';\nexport { BlockDefinitionRegistry } from '../blocks/definitions';\nexport { GLOBAL_STYLE_GROUPS } from '../blocks/styles';\nexport { BlockConversionError } from '../blocks/conversion';\nexport type { OutputMode } from '../blocks/block-type';\nexport { GeneratedMjml } from '../compilation/generated-mjml';\nexport { BlockTemplateCatalog } from '../templates/blocks/catalog';\nexport type { BlockTemplateDescriptor } from '../templates/blocks/catalog';\nexport type { BlockPreviewInput } from '../renderers/marked-preview';\nexport { BlockContentGuard } from '../blocks/content-guard';\nexport { BlockMjmlGenerator } from '../blocks/email-generator';\nexport { BlockPageGenerator } from '../blocks/page-generator';\nexport { BlockEmailRenderer } from '../blocks/email-renderer';\nexport { BlockToHtmlConversion } from '../blocks/conversion';\nexport { BlockChecker, GMAIL_CLIP_BYTES, GMAIL_NEAR_CLIP_BYTES } from '../blocks/block-checks';\nexport type { BlockCheck, BlockCheckCode } from '../blocks/block-checks';\nexport type { BlockDevice } from '../core/block-document';\n"],"mappings":";;;;;AAKA,IAAasC,IAAb,MAAwF;CACtF,QAAyB,IAAIL,EAAiB;CAC9C,uBAAwB,IAAI,IAAgB;CAC5C,WAAmB;CAGnB,MAAM,QAAQ,GAAiC;EAC7C,OAAO,KAAK,IAAIM,CAAM;CACxB;CAGA,MAAM,iBAAiB,GAAsC;EAC3D,IAAI,EAAEC,aAAgBH,IAAgB,MAAU,MAAM,uBAAuB;EAC7E,OAAO,KAAK,IAAIG,EAAK,QAAQA,EAAK,SAAS;CAC7C;CAEA,MAAc,IAAI,GAAgB,GAAgD;EAChF,IAAI,KAAK,UAAU,MAAU,MAAM,mBAAmB;EAEtD,IADA,KAAK,MAAM,OAAOD,GAAQE,CAAS,GAC/B,KAAK,KAAK,QAAQN,EAAe,cAAc,MAAU,MAAM,eAAe;EAClF,IAAMO,IAA0BD,IAAY;GAAE;GAAQ,WAAW,CAAC,GAAGA,CAAS;EAAE,IAAIF;EACpF,OAAO,IAAI,SAAiB,GAAS,MAAW;GAC9C,IAAMI,IAAS,IAAI,OAAO,IAAA;;IAAA,IAAA,IAAA,uCAAA,YAAA,GAAA,CAAA,CAAA3C;IAAA,KAAA,YAAA;GAAA,GAAiD,EACzE,MAAM,SACR,CAAC,GACK4C,UAAe;IAGnB,AAFA,aAAaC,CAAK,GAClBF,EAAO,UAAU,GACjB,KAAK,KAAK,OAAOG,CAAM;GACzB,GACMA,UAAe;IAEnB,AADAF,EAAO,GACPG,EAAO,gBAAI,MAAM,mBAAmB,CAAC;GACvC,GACMF,IAAQ,iBAAiB;IAE7B,AADAD,EAAO,GACPG,EAAO,gBAAI,MAAM,iBAAiB,CAAC;GACrC,GAAGZ,EAAe,SAAS;GAmB3B,AAlBA,KAAK,KAAK,IAAIW,CAAM,GACpB,EAAO,aAAa,MAAiC;IACnD,IAAI;KACF,IAAME,IAAUC,EAAM;KACtB,IAAI,CAACD,KAAW,OAAOA,KAAY,YAAY,EAAE,UAAUA,IACzD,MAAU,MAAM,gBAAgB;KAClC,IAAME,IAAO,KAAK,MAAM,OAAOF,EAAQ,IAAI;KAE3C,AADAJ,EAAO,GACPO,EAAQD,CAAI;IACd,SAASE,GAAO;KAEd,AADAR,EAAO,GACPG,EAAOK,CAAK;IACd;GACF,GACA,EAAO,gBAAgB;IAErB,AADAR,EAAO,GACPG,EAAO,gBAAI,MAAM,gBAAgB,CAAC;GACpC,GACAJ,EAAO,YAAYD,CAAO;EAC5B,CAAC;CACH;CAEA,UAAgB;EACd,KAAK,WAAW;EAChB,KAAK,IAAMI,KAAU,CAAC,GAAG,KAAK,IAAI,GAAG,EAAO;CAC9C;AACF;;;AC1DA,SAAgBO,EAAa,GAAyB;CACpD,OAAO,IAAItB,QAAoB,IAAIO,EAAoB,CAAC,CAAC,CAAC,OAAOgB,CAAO;AAC1E;AAGA,SAAgBC,EAAkB,GAAmD;CACnF,OAAO,IAAI5B,QAAyB,IAAIW,EAAoB,CAAC,CAAC,CAAC,OAAOgB,CAAO;AAC/E;AAGA,SAAgBE,EAAmB,GAA6C;CAC9E,OAAO,IAAI7B,QAAyB,IAAIW,EAAoB,CAAC,CAAC,CAAC,QAAQgB,CAAO;AAChF"}

package/dist/canvas-runtime/action-bar.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasContext } from './context';
+import type { ControlsOverlay } from './overlay';
+export interface ActionBarEvents {
+    /** The text of the selected block is opened for editing. */
+    edit(): void;
+    /** A press on the handle starts moving the selected block. */
+    grab(event: PointerEvent, handle: HTMLElement): void;
+    /** The element the bar must not cover while its text is being edited. */
+    editingId(): string | undefined;
+}
+/** The actions of the selected block, always next to it and never over a text being edited. */
+export declare class ActionBar {
+    #private;
+    private readonly ctx;
+    private readonly overlay;
+    private readonly events;
+    readonly handle: HTMLButtonElement;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay, events: ActionBarEvents);
+}

package/dist/canvas-runtime/auto-scroll.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Scrolls the frame while a drag rests near its top or bottom edge. It runs on its own clock, so
+ * the piece keeps moving when the pointer stands still.
+ */
+export declare class AutoScroll {
+    #private;
+    /** `after` runs after every scroll step, to find the destination under the same point again. */
+    update(y: number, after: () => void): void;
+    stop(): void;
+}

package/dist/canvas-runtime/block-drag.d.ts

@@ -0,0 +1,29 @@
+import type { CanvasContext } from './context';
+import type { DropTargets } from './drop-targets';
+import type { TextSession } from './text-session';
+/**
+ * Moves a block with the pointer and follows a block which the host drags in from its palette.
+ * One gesture at a time; nothing changes in the document before a completed drop.
+ */
+export declare class BlockDrag {
+    #private;
+    private readonly ctx;
+    private readonly targets;
+    private readonly text;
+    private readonly handle;
+    constructor(ctx: CanvasContext, targets: DropTargets, text: TextSession, handle: HTMLElement);
+    get sourceId(): string | undefined;
+    /** True once: a drag is never also the click which follows it. */
+    consumeClick(): boolean;
+    cancel(): void;
+    /** The window lost the pointer for good: no touch is still down. */
+    interrupt(): void;
+    start(event: PointerEvent, sourceId: string | undefined, capture: HTMLElement): boolean;
+    /** The handle of the action bar: a text being edited is concluded before its block moves. */
+    grab(event: PointerEvent): void;
+    /**
+     * A block dragged from the palette of the host, or an image file from the desktop, reported
+     * as points of this frame.
+     */
+    insertion(phase: unknown, x: unknown, y: unknown, file?: unknown): void;
+}

package/dist/canvas-runtime/bridge.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasBridgeConfiguration } from '../renderers/canvas-bridge';
+/**
+ * The only executable code of the opaque preview. It composes the modules of the runtime and
+ * routes the messages of the host; each interaction lives in its own module.
+ */
+export declare function installCanvasBridge(cfg: CanvasBridgeConfiguration): void;

package/dist/canvas-runtime/context.d.ts

@@ -0,0 +1,53 @@
+import type { CanvasBridgeConfiguration, CanvasBridgeRegion } from '../renderers/canvas-bridge';
+import { BridgeChannel } from './messages';
+export type Placement = 'before' | 'after' | 'inside';
+export interface FramePoint {
+    readonly x: number;
+    readonly y: number;
+}
+export declare function isRegion(value: unknown): value is CanvasBridgeRegion;
+/**
+ * What every module of the runtime shares: the channel to the host, the regions of the revision
+ * on screen, the selection and one measuring frame. It decides nothing about interaction.
+ */
+export declare class CanvasContext {
+    #private;
+    readonly cfg: CanvasBridgeConfiguration;
+    readonly controls: HTMLElement;
+    readonly lifecycle: AbortController;
+    readonly channel: BridgeChannel;
+    readonly marked: Map<string, HTMLElement>;
+    regions: Map<string, CanvasBridgeRegion>;
+    readOnly: boolean;
+    selectedId: string | undefined;
+    disposed: boolean;
+    /** A block or palette gesture is in course: hover feedback stays out of the way. */
+    dragging: boolean;
+    /** When the keyboard last asked for the menu of a block, to ignore the event the key fires. */
+    keyboardMenu: number;
+    constructor(cfg: CanvasBridgeConfiguration, controls: HTMLElement);
+    get signal(): AbortSignal;
+    index(): void;
+    /**
+     * The element whose text is edited in place: the block itself, or the element inside it which
+     * carries the edit mark of the same block (the text of an e-mail cell, generated by a block
+     * piece). The host already admitted that mark only inside its own block.
+     */
+    textElement(id: string): HTMLElement | undefined;
+    setRegions(regions: readonly CanvasBridgeRegion[]): void;
+    send(type: string, payload?: Record<string, unknown>): void;
+    select(id: string | undefined): void;
+    /** Runs before this frame asks the host to select another block. */
+    beforeSelect(action: () => void): void;
+    regionFrom(element: Element | null): string | undefined;
+    /** The closest selectable ancestor in the piece, whatever plain markup lies between. */
+    parentOf(id: string | undefined): string | undefined;
+    /** Regions which share the parent of `id`, in document order. */
+    siblings(id: string): string[];
+    isControls(event: Event): boolean;
+    /** Hit test of the piece itself: the trusted overlay never answers for a document element. */
+    elementAt(x: number, y: number): Element | null;
+    onMeasure(measure: () => void): void;
+    schedule(): void;
+    dispose(): void;
+}

package/dist/canvas-runtime/document-sync.d.ts

@@ -0,0 +1,21 @@
+import type { BlockDrag } from './block-drag';
+import type { CanvasContext } from './context';
+import type { DropTargets } from './drop-targets';
+import type { ImageTools } from './image-tools';
+import type { SelectionLayer } from './selection-layer';
+import type { TextSession } from './text-session';
+export interface DocumentSyncParts {
+    readonly text: TextSession;
+    readonly drag: BlockDrag;
+    readonly targets: DropTargets;
+    readonly selection: SelectionLayer;
+    readonly images: ImageTools;
+}
+/** Brings the next validated revision into the window which is already running. */
+export declare class DocumentSync {
+    #private;
+    private readonly ctx;
+    private readonly parts;
+    constructor(ctx: CanvasContext, parts: DocumentSyncParts);
+    apply(message: Record<string, unknown>): void;
+}

package/dist/canvas-runtime/drop-targets.d.ts

@@ -0,0 +1,34 @@
+import type { CanvasContext, Placement } from './context';
+import type { ControlsOverlay } from './overlay';
+export type DropDestination = {
+    readonly targetId: string;
+    readonly placement: Placement;
+} | {
+    readonly end: true;
+}
+/** A dropped image file over an image: it takes the place of that image. */
+ | {
+    readonly replace: string;
+};
+/**
+ * Decides where a dragged block would land and draws the insertion marker. Only destinations the
+ * host declared valid are ever shown; the command itself is validated again by the host.
+ */
+export declare class DropTargets {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay);
+    get destination(): DropDestination | undefined;
+    clear(): void;
+    /** A new revision invalidates every destination the host had declared. */
+    reset(): void;
+    /** Where the selected block may be moved to. */
+    setMovement(sourceId: unknown, entries: unknown): void;
+    /** Where a new block may be inserted. */
+    setInsertion(entries: unknown): void;
+    /**
+     * Finds the destination under a point of the frame and shows it, or shows nothing. A file
+     * held over an image replaces that image instead of landing next to it.
+     */
+    resolve(x: number, y: number, sourceId?: string, file?: boolean): void;
+}

package/dist/canvas-runtime/embed-markers.d.ts

@@ -0,0 +1,15 @@
+import type { BlockDrag } from './block-drag';
+import type { CanvasContext } from './context';
+import type { ControlsOverlay } from './overlay';
+/**
+ * Embedded content never loads inside the editor, and a click on a frame would not reach this
+ * document anyway. Each one on screen gets a marker drawn over it, which selects, moves and opens
+ * the menu of the block it stands for.
+ */
+export declare class EmbedMarkers {
+    #private;
+    private readonly ctx;
+    private readonly overlay;
+    private readonly drag;
+    constructor(ctx: CanvasContext, overlay: ControlsOverlay, drag: BlockDrag);
+}

package/dist/canvas-runtime/file-guard.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasContext } from './context';
+/**
+ * A file dragged from the system straight over the frame. The frame never takes it: its drop is
+ * cancelled before any listener of the document sees it (no navigation to the file, no data for
+ * the page), and the host is told, without any data, that a file drag is over the piece so it can
+ * raise its own layer, which accepts the file through the upload of the host or refuses it.
+ */
+export declare class FileGuard {
+    #private;
+    private readonly ctx;
+    constructor(ctx: CanvasContext);
+}