@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/affine-model/elements/wardley/wardley.js

@@ -32,18 +32,22 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
-import { field, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
 /**
  * A static "Wardley map background": an L-shaped axes frame (Evolution X /
  * Value Chain Y) with the four evolution phase dividers and labels, drawn on
  * the surface canvas. The user places regular edgeless elements on top of it.
  *
- * Extends {@link GfxPrimitiveElementModel} so it inherits selection, move,
- * copy/paste, duplicate, align and undo/redo for free.
+ * An INSTANCE of the framework-background primitive
+ * ({@link FrameworkBackgroundElementModel}): the geometry and the passive-canvas
+ * behaviour come from the primitive, what the map looks like comes from the
+ * `WARDLEY_BACKGROUND` declaration in `@labre/affine-gfx-wardley`, and the
+ * fields below are the persisted document — unchanged, and not the primitive's
+ * business.
  */
 let WardleyBackgroundElementModel = (() => {
-    let _classSuper = GfxPrimitiveElementModel;
+    let _classSuper = FrameworkBackgroundElementModel;
     let _banded_decorators;
     let _banded_initializers = [];
     let _banded_extraInitializers = [];
@@ -117,16 +121,16 @@ let WardleyBackgroundElementModel = (() => {
             _variant_decorators = [field('classic')];
             _showGradient_decorators = [field(true)];
             _resizeEnabled_decorators = [field(false)];
-            _xAxisTitle_decorators = [field('Evolution')];
-            _yAxisTitle_decorators = [field('Value Chain')];
-            _evolutionStart_decorators = [field('Uncharted')];
-            _evolutionEnd_decorators = [field('Industrialized')];
-            _visibilityHigh_decorators = [field('Visible')];
-            _visibilityLow_decorators = [field('Invisible')];
-            _phase0_decorators = [field('Genesis')];
-            _phase1_decorators = [field('Custom-Built')];
-            _phase2_decorators = [field('Product (+Rental)')];
-            _phase3_decorators = [field('Commodity (+Utility)')];
+            _xAxisTitle_decorators = [field()];
+            _yAxisTitle_decorators = [field()];
+            _evolutionStart_decorators = [field()];
+            _evolutionEnd_decorators = [field()];
+            _visibilityHigh_decorators = [field()];
+            _visibilityLow_decorators = [field()];
+            _phase0_decorators = [field()];
+            _phase1_decorators = [field()];
+            _phase2_decorators = [field()];
+            _phase3_decorators = [field()];
             _showXAxis_decorators = [field(true)];
             _showYAxis_decorators = [field(true)];
             _showColumnDividers_decorators = [field(true)];
@@ -162,28 +166,6 @@ let WardleyBackgroundElementModel = (() => {
         get type() {
             return 'wardley';
         }
-        /**
-         * The background is a passive canvas: connectors must not snap their
-         * endpoints to it (a Wardley arrow should connect nodes, never the map).
-         */
-        get connectable() {
-            return false;
-        }
-        containsBound(bounds) {
-            const points = getPointsFromBoundWithRotation(this);
-            return points.some(point => bounds.containsPoint(point));
-        }
-        getLineIntersections(start, end) {
-            const points = getPointsFromBoundWithRotation(this);
-            return linePolygonIntersects(start, end, points);
-        }
-        getNearestPoint(point) {
-            return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
-        }
-        includesPoint(x, y) {
-            const points = getPointsFromBoundWithRotation(this);
-            return pointInPolygon([x, y], points);
-        }
         #banded_accessor_storage = __runInitializers(this, _banded_initializers, false);
         get banded() { return this.#banded_accessor_storage; }
         set banded(value) { this.#banded_accessor_storage = value; }
@@ -196,35 +178,46 @@ let WardleyBackgroundElementModel = (() => {
         #resizeEnabled_accessor_storage = (__runInitializers(this, _showGradient_extraInitializers), __runInitializers(this, _resizeEnabled_initializers, false));
         get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
         set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
-        #xAxisTitle_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _xAxisTitle_initializers, 'Evolution'));
-        // ── Editable label texts (defaults mirror the original hard-coded ones) ─
+        #xAxisTitle_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _xAxisTitle_initializers, undefined));
+        // ── Editable label texts ──────────────────────────────────────────────
+        //
+        // Deliberately DEFAULTED TO `undefined`, and therefore written nowhere: an
+        // `undefined` default stays absent from the Y.Map until something assigns it
+        // (see `field.ts`), which is what keeps an optional field shippable without a
+        // migration.
+        //
+        // Absent means "the user has never renamed this one", and only then can the
+        // `WARDLEY_BACKGROUND` declaration fall through to its i18n key — with a hard
+        // default here, the key would be unreachable and the map would be English
+        // forever. Any value the user types is written and wins from then on, and a
+        // map authored before this change carries all ten and is untouched.
         get xAxisTitle() { return this.#xAxisTitle_accessor_storage; }
         set xAxisTitle(value) { this.#xAxisTitle_accessor_storage = value; }
-        #yAxisTitle_accessor_storage = (__runInitializers(this, _xAxisTitle_extraInitializers), __runInitializers(this, _yAxisTitle_initializers, 'Value Chain'));
+        #yAxisTitle_accessor_storage = (__runInitializers(this, _xAxisTitle_extraInitializers), __runInitializers(this, _yAxisTitle_initializers, undefined));
         get yAxisTitle() { return this.#yAxisTitle_accessor_storage; }
         set yAxisTitle(value) { this.#yAxisTitle_accessor_storage = value; }
-        #evolutionStart_accessor_storage = (__runInitializers(this, _yAxisTitle_extraInitializers), __runInitializers(this, _evolutionStart_initializers, 'Uncharted'));
+        #evolutionStart_accessor_storage = (__runInitializers(this, _yAxisTitle_extraInitializers), __runInitializers(this, _evolutionStart_initializers, undefined));
         get evolutionStart() { return this.#evolutionStart_accessor_storage; }
         set evolutionStart(value) { this.#evolutionStart_accessor_storage = value; }
-        #evolutionEnd_accessor_storage = (__runInitializers(this, _evolutionStart_extraInitializers), __runInitializers(this, _evolutionEnd_initializers, 'Industrialized'));
+        #evolutionEnd_accessor_storage = (__runInitializers(this, _evolutionStart_extraInitializers), __runInitializers(this, _evolutionEnd_initializers, undefined));
         get evolutionEnd() { return this.#evolutionEnd_accessor_storage; }
         set evolutionEnd(value) { this.#evolutionEnd_accessor_storage = value; }
-        #visibilityHigh_accessor_storage = (__runInitializers(this, _evolutionEnd_extraInitializers), __runInitializers(this, _visibilityHigh_initializers, 'Visible'));
+        #visibilityHigh_accessor_storage = (__runInitializers(this, _evolutionEnd_extraInitializers), __runInitializers(this, _visibilityHigh_initializers, undefined));
         get visibilityHigh() { return this.#visibilityHigh_accessor_storage; }
         set visibilityHigh(value) { this.#visibilityHigh_accessor_storage = value; }
-        #visibilityLow_accessor_storage = (__runInitializers(this, _visibilityHigh_extraInitializers), __runInitializers(this, _visibilityLow_initializers, 'Invisible'));
+        #visibilityLow_accessor_storage = (__runInitializers(this, _visibilityHigh_extraInitializers), __runInitializers(this, _visibilityLow_initializers, undefined));
         get visibilityLow() { return this.#visibilityLow_accessor_storage; }
         set visibilityLow(value) { this.#visibilityLow_accessor_storage = value; }
-        #phase0_accessor_storage = (__runInitializers(this, _visibilityLow_extraInitializers), __runInitializers(this, _phase0_initializers, 'Genesis'));
+        #phase0_accessor_storage = (__runInitializers(this, _visibilityLow_extraInitializers), __runInitializers(this, _phase0_initializers, undefined));
         get phase0() { return this.#phase0_accessor_storage; }
         set phase0(value) { this.#phase0_accessor_storage = value; }
-        #phase1_accessor_storage = (__runInitializers(this, _phase0_extraInitializers), __runInitializers(this, _phase1_initializers, 'Custom-Built'));
+        #phase1_accessor_storage = (__runInitializers(this, _phase0_extraInitializers), __runInitializers(this, _phase1_initializers, undefined));
         get phase1() { return this.#phase1_accessor_storage; }
         set phase1(value) { this.#phase1_accessor_storage = value; }
-        #phase2_accessor_storage = (__runInitializers(this, _phase1_extraInitializers), __runInitializers(this, _phase2_initializers, 'Product (+Rental)'));
+        #phase2_accessor_storage = (__runInitializers(this, _phase1_extraInitializers), __runInitializers(this, _phase2_initializers, undefined));
         get phase2() { return this.#phase2_accessor_storage; }
         set phase2(value) { this.#phase2_accessor_storage = value; }
-        #phase3_accessor_storage = (__runInitializers(this, _phase2_extraInitializers), __runInitializers(this, _phase3_initializers, 'Commodity (+Utility)'));
+        #phase3_accessor_storage = (__runInitializers(this, _phase2_extraInitializers), __runInitializers(this, _phase3_initializers, undefined));
         get phase3() { return this.#phase3_accessor_storage; }
         set phase3(value) { this.#phase3_accessor_storage = value; }
         #showXAxis_accessor_storage = (__runInitializers(this, _phase3_extraInitializers), __runInitializers(this, _showXAxis_initializers, true));

package/dist/_pkgs/affine-shared/adapters/html/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockHtmlAdapterMatcherIdentifier = createIdentifier('BlockHtmlAdapterMatcher');
 export function BlockHtmlAdapterExtension(matcher) {
     const identifier = BlockHtmlAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/markdown/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockMarkdownAdapterMatcherIdentifier = createIdentifier('BlockMarkdownAdapterMatcher');
 export function BlockMarkdownAdapterExtension(matcher) {
     const identifier = BlockMarkdownAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/markdown/delta-converter.d.ts

@@ -2,6 +2,7 @@ import { type ServiceIdentifier } from '../../../global/di/index.js';
 import type { DeltaInsert, ExtensionType } from '../../../store/index.js';
 import type { PhrasingContent } from 'mdast';
 import type { AffineTextAttributes } from '../../types/index.js';
+import type { HtmlDeltaConverter } from '../html/delta-converter.js';
 import { type ASTToDeltaMatcher, DeltaASTConverter, type InlineDeltaMatcher } from '../types/delta-converter.js';
 import type { MarkdownAST } from './type.js';
 export type InlineDeltaToMarkdownAdapterMatcher = InlineDeltaMatcher<PhrasingContent>;
@@ -18,8 +19,12 @@ export declare class MarkdownDeltaConverter extends DeltaASTConverter<AffineText
     readonly configs: Map<string, string>;
     readonly inlineDeltaMatchers: InlineDeltaToMarkdownAdapterMatcher[];
     readonly markdownASTToDeltaMatchers: MarkdownASTToDeltaMatcher[];
-    constructor(configs: Map<string, string>, inlineDeltaMatchers: InlineDeltaToMarkdownAdapterMatcher[], markdownASTToDeltaMatchers: MarkdownASTToDeltaMatcher[]);
+    readonly htmlDeltaConverter?: HtmlDeltaConverter | undefined;
+    constructor(configs: Map<string, string>, inlineDeltaMatchers: InlineDeltaToMarkdownAdapterMatcher[], markdownASTToDeltaMatchers: MarkdownASTToDeltaMatcher[], htmlDeltaConverter?: HtmlDeltaConverter | undefined);
+    private _convertHtmlToDelta;
     applyTextFormatting(delta: DeltaInsert<AffineTextAttributes>): PhrasingContent;
+    private _mergeInlineHtml;
+    private _astChildrenToDelta;
     astToDelta(ast: MarkdownAST): DeltaInsert<AffineTextAttributes>[];
     deltaToAST(deltas: DeltaInsert<AffineTextAttributes>[], depth?: number): PhrasingContent[];
 }

package/dist/_pkgs/affine-shared/adapters/markdown/delta-converter.js

@@ -1,5 +1,69 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
+import rehypeParse from 'rehype-parse';
+import { unified } from 'unified';
+import { rehypeInlineToBlock, rehypeWrapInlineElements, } from '../html/rehype-plugins/index.js';
 import { DeltaASTConverter, } from '../types/delta-converter.js';
+const INLINE_HTML_TAGS = new Set([
+    'span',
+    'strong',
+    'b',
+    'em',
+    'i',
+    'del',
+    'u',
+    'mark',
+    'code',
+    'ins',
+    'bdi',
+    'bdo',
+]);
+const VOID_HTML_TAGS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+const ALLOWED_INLINE_HTML_TAGS = new Set([
+    ...INLINE_HTML_TAGS,
+    ...VOID_HTML_TAGS,
+]);
+const isHtmlNode = (node) => node.type === 'html' && 'value' in node && typeof node.value === 'string';
+const isTextNode = (node) => node.type === 'text' && 'value' in node && typeof node.value === 'string';
+const getHtmlTagInfo = (value) => {
+    const closingMatch = value.match(/^<\/([A-Za-z][A-Za-z0-9-]*)\s*>$/);
+    if (closingMatch) {
+        return {
+            name: closingMatch[1].toLowerCase(),
+            kind: 'close',
+        };
+    }
+    const selfClosingMatch = value.match(/^<([A-Za-z][A-Za-z0-9-]*)(\s[^>]*)?\/>$/i);
+    if (selfClosingMatch) {
+        return {
+            name: selfClosingMatch[1].toLowerCase(),
+            kind: 'self',
+        };
+    }
+    const openingMatch = value.match(/^<([A-Za-z][A-Za-z0-9-]*)(\s[^>]*)?>$/);
+    if (openingMatch) {
+        const name = openingMatch[1].toLowerCase();
+        return {
+            name,
+            kind: VOID_HTML_TAGS.has(name) ? 'self' : 'open',
+        };
+    }
+    return null;
+};
 export const InlineDeltaToMarkdownAdapterMatcherIdentifier = createIdentifier('InlineDeltaToMarkdownAdapterMatcher');
 export function InlineDeltaToMarkdownAdapterExtension(matcher) {
     const identifier = InlineDeltaToMarkdownAdapterMatcherIdentifier(matcher.name);
@@ -21,11 +85,28 @@ export function MarkdownASTToDeltaExtension(matcher) {
     };
 }
 export class MarkdownDeltaConverter extends DeltaASTConverter {
-    constructor(configs, inlineDeltaMatchers, markdownASTToDeltaMatchers) {
+    constructor(configs, inlineDeltaMatchers, markdownASTToDeltaMatchers, htmlDeltaConverter) {
         super();
         this.configs = configs;
         this.inlineDeltaMatchers = inlineDeltaMatchers;
         this.markdownASTToDeltaMatchers = markdownASTToDeltaMatchers;
+        this.htmlDeltaConverter = htmlDeltaConverter;
+    }
+    _convertHtmlToDelta(html) {
+        if (!this.htmlDeltaConverter) {
+            return [{ insert: html }];
+        }
+        try {
+            const processor = unified()
+                .use(rehypeParse, { fragment: true })
+                .use(rehypeInlineToBlock)
+                .use(rehypeWrapInlineElements);
+            const ast = processor.runSync(processor.parse(html));
+            return this.htmlDeltaConverter.astToDelta(ast, { trim: false });
+        }
+        catch {
+            return [{ insert: html }];
+        }
     }
     applyTextFormatting(delta) {
         let mdast = {
@@ -46,11 +127,88 @@ export class MarkdownDeltaConverter extends DeltaASTConverter {
         }
         return mdast;
     }
+    _mergeInlineHtml(children, startIndex) {
+        const startNode = children[startIndex];
+        if (!isHtmlNode(startNode)) {
+            return null;
+        }
+        const startTag = getHtmlTagInfo(startNode.value);
+        if (!startTag ||
+            startTag.kind !== 'open' ||
+            !INLINE_HTML_TAGS.has(startTag.name)) {
+            return null;
+        }
+        const stack = [startTag.name];
+        let html = startNode.value;
+        let endIndex = startIndex;
+        for (let i = startIndex + 1; i < children.length; i++) {
+            const node = children[i];
+            if (isHtmlNode(node)) {
+                const info = getHtmlTagInfo(node.value);
+                if (!info) {
+                    html += node.value;
+                    continue;
+                }
+                if (info.kind === 'open') {
+                    if (!ALLOWED_INLINE_HTML_TAGS.has(info.name)) {
+                        return null;
+                    }
+                    stack.push(info.name);
+                    html += node.value;
+                    continue;
+                }
+                if (info.kind === 'self') {
+                    if (!ALLOWED_INLINE_HTML_TAGS.has(info.name)) {
+                        return null;
+                    }
+                    html += node.value;
+                    continue;
+                }
+                if (!ALLOWED_INLINE_HTML_TAGS.has(info.name)) {
+                    return null;
+                }
+                const last = stack[stack.length - 1];
+                if (last !== info.name) {
+                    return null;
+                }
+                stack.pop();
+                html += node.value;
+                endIndex = i;
+                if (stack.length === 0) {
+                    return {
+                        endIndex,
+                        deltas: this._convertHtmlToDelta(html),
+                    };
+                }
+                continue;
+            }
+            if (isTextNode(node)) {
+                html += node.value;
+                continue;
+            }
+            return null;
+        }
+        return null;
+    }
+    _astChildrenToDelta(children) {
+        const deltas = [];
+        for (let i = 0; i < children.length; i++) {
+            const merged = this._mergeInlineHtml(children, i);
+            if (merged) {
+                deltas.push(...merged.deltas);
+                i = merged.endIndex;
+                continue;
+            }
+            deltas.push(...this.astToDelta(children[i]));
+        }
+        return deltas;
+    }
     astToDelta(ast) {
         const context = {
             configs: this.configs,
             options: Object.create(null),
             toDelta: (ast) => this.astToDelta(ast),
+            htmlToDelta: (html) => this._convertHtmlToDelta(html),
         };
         for (const matcher of this.markdownASTToDeltaMatchers) {
             if (matcher.match(ast)) {
@@ -58,7 +216,7 @@ export class MarkdownDeltaConverter extends DeltaASTConverter {
             }
         }
         return 'children' in ast
-            ? ast.children.flatMap(child => this.astToDelta(child))
+            ? this._astChildrenToDelta(ast.children)
             : [];
     }
     deltaToAST(deltas, depth = 0) {

package/dist/_pkgs/affine-shared/adapters/markdown/markdown.js

@@ -4,6 +4,7 @@ import remarkMath from 'remark-math';
 import remarkParse from 'remark-parse';
 import remarkStringify from 'remark-stringify';
 import { unified } from 'unified';
+import { HtmlASTToDeltaMatcherIdentifier, HtmlDeltaConverter, InlineDeltaToHtmlAdapterMatcherIdentifier, } from '../html/delta-converter.js';
 import { AdapterFactoryIdentifier } from '../types/index.js';
 import { BlockMarkdownAdapterMatcherIdentifier, } from './block-adapter.js';
 import { InlineDeltaToMarkdownAdapterMatcherIdentifier, MarkdownASTToDeltaMatcherIdentifier, MarkdownDeltaConverter, } from './delta-converter.js';
@@ -103,8 +104,11 @@ export class MarkdownAdapter extends BaseAdapter {
         const blockMatchers = Array.from(provider.getAll(BlockMarkdownAdapterMatcherIdentifier).values());
         const inlineDeltaToMarkdownAdapterMatchers = Array.from(provider.getAll(InlineDeltaToMarkdownAdapterMatcherIdentifier).values());
         const markdownInlineToDeltaMatchers = Array.from(provider.getAll(MarkdownASTToDeltaMatcherIdentifier).values());
+        const inlineDeltaToHtmlAdapterMatchers = Array.from(provider.getAll(InlineDeltaToHtmlAdapterMatcherIdentifier).values());
+        const htmlInlineToDeltaMatchers = Array.from(provider.getAll(HtmlASTToDeltaMatcherIdentifier).values());
+        const htmlDeltaConverter = new HtmlDeltaConverter(job.adapterConfigs, inlineDeltaToHtmlAdapterMatchers, htmlInlineToDeltaMatchers, provider);
         this.blockMatchers = blockMatchers;
-        this.deltaConverter = new MarkdownDeltaConverter(job.adapterConfigs, inlineDeltaToMarkdownAdapterMatchers, markdownInlineToDeltaMatchers);
+        this.deltaConverter = new MarkdownDeltaConverter(job.adapterConfigs, inlineDeltaToMarkdownAdapterMatchers, markdownInlineToDeltaMatchers, htmlDeltaConverter);
         this.preprocessorManager = new MarkdownPreprocessorManager(provider);
     }
     _astToMarkdown(ast) {

package/dist/_pkgs/affine-shared/adapters/notion-html/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockNotionHtmlAdapterMatcherIdentifier = createIdentifier('BlockNotionHtmlAdapterMatcher');
 export function BlockNotionHtmlAdapterExtension(matcher) {
     const identifier = BlockNotionHtmlAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/notion-html/delta-converter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import isEqual from 'lodash-es/isEqual.js';
 import { DeltaASTConverter, } from '../types/delta-converter.js';
 export const NotionHtmlASTToDeltaMatcherIdentifier = createIdentifier('NotionHtmlASTToDeltaMatcher');

package/dist/_pkgs/affine-shared/adapters/plain-text/block-adapter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const BlockPlainTextAdapterMatcherIdentifier = createIdentifier('BlockPlainTextAdapterMatcher');
 export function BlockPlainTextAdapterExtension(matcher) {
     const identifier = BlockPlainTextAdapterMatcherIdentifier(matcher.flavour);

package/dist/_pkgs/affine-shared/adapters/plain-text/delta-converter.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import { DeltaASTConverter, } from '../types/delta-converter.js';
 export const InlineDeltaToPlainTextAdapterMatcherIdentifier = createIdentifier('InlineDeltaToPlainTextAdapterMatcher');
 export function InlineDeltaToPlainTextAdapterExtension(matcher) {

package/dist/_pkgs/affine-shared/adapters/types/delta-converter.d.ts

@@ -32,5 +32,6 @@ export type ASTToDeltaMatcher<AST> = {
         configs: Map<string, string>;
         options: DeltaASTConverterOptions;
         toDelta: (ast: AST, options?: DeltaASTConverterOptions) => DeltaInsert<AffineTextAttributes>[];
+        htmlToDelta?: (html: string) => DeltaInsert<AffineTextAttributes>[];
     }) => DeltaInsert<AffineTextAttributes>[];
 };

package/dist/_pkgs/affine-shared/adapters/utils/color.d.ts

@@ -0,0 +1,24 @@
+export type ParsedColor = {
+    r: number;
+    g: number;
+    b: number;
+    alpha: number;
+};
+/**
+ * Parse the subset of CSS colour syntax that turns up in pasted HTML: hex,
+ * `rgb()`/`rgba()`, `hsl()`/`hsla()` and the basic colour keywords. Anything
+ * else — `color-mix()`, a custom property, an unknown keyword — is `null`.
+ */
+export declare const parseCssColor: (value: string) => ParsedColor | null;
+/**
+ * Map a CSS colour onto the nearest supported text highlight, or `null` when
+ * nothing is near enough. `null` is the good outcome for the reader: text with
+ * no colour follows the theme, whereas a wrong colour can leave it unreadable
+ * in one of the two themes.
+ */
+export declare const resolveNearestSupportedColor: (color: string) => string | null;
+/**
+ * Read the `color` declaration out of an inline `style` attribute, leaving
+ * `background-color` and friends alone.
+ */
+export declare const extractColorFromStyle: (style: string | undefined) => string | null;