docier-web 0.1.0

package/dist/tokens/module.js

@@ -0,0 +1,861 @@
+import { childElements, isWElement } from '../model/index.js';
+import { CancelledChangeError } from '../api/commands.js';
+import { commandIdOf } from '../api/errors.js';
+import { SEVERITY_OF } from './issues.js';
+import { labelOf } from './catalogue.js';
+import { paletteOf } from './catalogue.js';
+import { instanceRefs, scanTokens, tokenAncestorOf, tokenAtOffset } from './binding.js';
+import { applyDisplayPlan, planDisplay } from './display.js';
+import { createTokenEngine } from './engine.js';
+import { tokenEventsOf } from './events.js';
+import { fillDocument } from './fill.js';
+import { DEFAULT_IMAGE_WIDTH_PX, buildInlineDrawing, bytesOfBlob, decodeDataUri, extensionOfMime, imageDimensionsOf, sizeFor, } from './images.js';
+import { insertToken } from './insert.js';
+import { DEFAULT_TRIGGER, tokenTagOf } from './keys.js';
+import { unlinkTokens } from './unlink.js';
+import { plainTextOf, richKindOf } from './values.js';
+import { writeDrawing } from './write.js';
+const EMPTY_SUMMARY = {
+    filled: 0,
+    unresolved: 0,
+    failed: 0,
+    loopsExpanded: 0,
+    issues: [],
+    durationMs: 0,
+};
+const DISABLED_REASON = 'Tokenization is not enabled for this document';
+const NO_DOCUMENT = 'No document is loaded';
+const NO_CATALOGUE = 'No token catalogue was supplied to the module';
+const INSIDE_TOKEN = 'The caret is inside a token';
+const NO_TOKEN_HERE = 'Place the caret inside a token first';
+const UNKNOWN_KEY = (key) => `The catalogue does not define the token ${key}`;
+const mutationOf = (value, changed) => ({
+    value,
+    changed,
+    affectedRanges: [],
+    invalidation: { kind: 'document' },
+});
+const displayModeFromConfig = (value) => {
+    if (value === 'fieldCode' || value === 'code')
+        return 'code';
+    if (value === 'resolved' || value === 'value')
+        return 'value';
+    return 'label';
+};
+const decodeImageBytes = async (source) => {
+    if (source.kind === 'blob') {
+        return { bytes: await bytesOfBlob(source.blob), mimeType: source.mimeType };
+    }
+    if (source.kind === 'dataUri')
+        return decodeDataUri(source.uri);
+    return undefined;
+};
+export const createTokenAttachment = (host, options = {}) => {
+    const events = tokenEventsOf(host.events);
+    const locale = options.locale ?? 'en-US';
+    const engine = createTokenEngine({
+        locale,
+        fallbackLocale: 'en-US',
+        trigger: options.trigger ?? host.config.tokenization.trigger ?? DEFAULT_TRIGGER,
+        display: options.display ?? displayModeFromConfig(host.config.tokenization.display),
+        issuePolicy: options.issuePolicy ?? 'warn',
+    });
+    engine.setCatalogue(options.catalogue ?? null);
+    const disposables = [];
+    const subscriptions = [];
+    let source;
+    let preview;
+    let datasetBeforePreview;
+    let docPrCounter = 0;
+    const enabled = () => host.config.tokenization.enabled === true;
+    const current = () => host.document;
+    const missingCatalogue = () => engine.index().catalogue === undefined;
+    const reasonOf = () => {
+        if (!enabled())
+            return DISABLED_REASON;
+        if (host.document === undefined)
+            return NO_DOCUMENT;
+        if (missingCatalogue())
+            return NO_CATALOGUE;
+        return undefined;
+    };
+    const envelope = () => ({
+        instanceId: host.id,
+        documentRevision: host.revision,
+        source: 'api',
+        timestamp: Date.now(),
+    });
+    const emitIssues = () => {
+        const payload = engine.issues().payload();
+        host.events.emit('docier:issues:change', { ...envelope(), ...payload });
+    };
+    const bound = () => {
+        const model = current();
+        return model === undefined ? [] : scanTokens(model);
+    };
+    const planDisplayAll = (tokens) => ({
+        changed: tokens.length > 0,
+        apply: () => {
+            const model = current();
+            if (model === undefined)
+                return;
+            const index = engine.index();
+            const settings = engine.options();
+            const data = engine.data();
+            for (const token of tokens) {
+                const plan = planDisplay({
+                    token,
+                    index,
+                    data,
+                    mode: settings.display,
+                    locale: settings.locale,
+                    fallbackLocale: settings.fallbackLocale,
+                    trigger: settings.trigger,
+                });
+                applyDisplayPlan(model, token, plan, data[token.ref.key]);
+            }
+        },
+    });
+    const prepareImages = async (model, images, tokens) => {
+        const placed = [];
+        const failed = [];
+        for (const image of images) {
+            const token = tokens.find((candidate) => candidate.ref.id === image.ref.id);
+            if (token === undefined)
+                continue;
+            const decoded = await decodeImageBytes(image.source);
+            if (decoded === undefined) {
+                failed.push({
+                    ref: image.ref,
+                    detail: 'Only blob and data URI image sources can be embedded without a host fetch',
+                });
+                continue;
+            }
+            const extension = extensionOfMime(decoded.mimeType);
+            if (extension === undefined) {
+                failed.push({ ref: image.ref, detail: `The image type ${decoded.mimeType} is not allowed` });
+                continue;
+            }
+            const media = await model.package.addMediaPart(model.package.mainDocumentPartName, decoded.bytes, decoded.mimeType, extension);
+            const natural = imageDimensionsOf(decoded.bytes, decoded.mimeType);
+            const maxWidthPx = image.sizing?.maxWidthPx ?? image.sizing?.width ?? DEFAULT_IMAGE_WIDTH_PX;
+            const size = sizeFor({ natural, maxWidthPx });
+            docPrCounter += 1;
+            placed.push({
+                control: token.element,
+                drawing: buildInlineDrawing({
+                    relationshipId: media.relationship.id,
+                    cx: size.cx,
+                    cy: size.cy,
+                    docPrId: docPrCounter,
+                    name: `Token ${image.ref.key}`,
+                    alt: image.alt ?? image.ref.key,
+                }),
+            });
+        }
+        return { placed, failed };
+    };
+    const planFill = async (mode) => {
+        const model = current();
+        if (model === undefined)
+            return undefined;
+        const gate = events.dispatch('docier:fill:before', {
+            ...envelope(),
+            mode,
+            tokenCount: bound().length,
+        });
+        if (gate.defaultPrevented)
+            return undefined;
+        const tokens = scanTokens(model);
+        const outcome = fillDocument({
+            model,
+            data: engine.data(),
+            index: engine.index(),
+            locale: engine.options().locale,
+            fallbackLocale: engine.options().fallbackLocale,
+            mode,
+            trigger: engine.options().trigger,
+            tokens,
+        });
+        const images = await prepareImages(model, outcome.images, tokens);
+        const summary = {
+            ...outcome.summary,
+            issues: [
+                ...outcome.summary.issues,
+                ...images.failed.map((item) => issueOf('image-unresolved', item.ref.key, item.detail, [item.ref])),
+            ],
+        };
+        return {
+            changed: true,
+            apply: () => {
+                const live = current();
+                if (live === undefined)
+                    return summary;
+                for (const item of images.placed) {
+                    const token = tokens.find((candidate) => candidate.element === item.control);
+                    if (token === undefined)
+                        continue;
+                    writeDrawing(live, token.control, item.drawing);
+                }
+                engine.reportIssues(summary.issues);
+                return summary;
+            },
+        };
+    };
+    const planInsert = (key, kind) => {
+        const model = current();
+        const target = caretTarget();
+        if (model === undefined || target === undefined)
+            return { changed: false, apply: () => false };
+        const entry = engine.index().entryOf(key);
+        if (entry === undefined) {
+            throw new CancelledChangeError(UNKNOWN_KEY(key));
+        }
+        if (tokenInside(model, target.element, target.offset)) {
+            throw new CancelledChangeError(INSIDE_TOKEN);
+        }
+        const label = labelOf(entry.label, engine.options().locale, engine.options().fallbackLocale, key);
+        const gate = events.dispatch('docier:token:beforeinsert', {
+            ...envelope(),
+            key,
+            kind,
+            tag: tokenTagOf(kind, key),
+            paragraphIndex: 0,
+        });
+        if (gate.defaultPrevented)
+            return { changed: false, apply: () => false };
+        const request = {
+            model,
+            paragraph: target.element,
+            offset: target.offset,
+            key,
+            kind,
+            label,
+            content: label,
+        };
+        return {
+            changed: true,
+            apply: () => {
+                const live = current();
+                if (live === undefined)
+                    return false;
+                const created = insertToken(request);
+                if (created === undefined)
+                    return false;
+                const tokens = scanTokens(live);
+                planDisplayAll(tokens).apply();
+                const inserted = tokens.find((token) => token.element === created);
+                if (inserted !== undefined) {
+                    events.emit('docier:token:insert', { ...envelope(), ref: inserted.ref, label });
+                }
+                return true;
+            },
+        };
+    };
+    const planUnlink = (refs, freeze) => {
+        const model = current();
+        if (model === undefined)
+            return { changed: false, apply: () => 0 };
+        const all = scanTokens(model);
+        const targets = refs.length === 0 ? all : all.filter((token) => refs.some((ref) => ref.id === token.ref.id));
+        if (targets.length === 0)
+            return { changed: false, apply: () => 0 };
+        const context = {
+            locale: engine.options().locale,
+            fallbackLocale: engine.options().fallbackLocale,
+        };
+        return {
+            changed: true,
+            apply: () => {
+                const live = current();
+                if (live === undefined)
+                    return 0;
+                const result = unlinkTokens(live, targets, freeze, (token) => {
+                    const value = engine.data()[token.ref.key];
+                    if (value === undefined)
+                        return undefined;
+                    return plainTextOf(value, engine.index().entryOf(token.ref.key), context);
+                });
+                for (const token of targets) {
+                    events.emit('docier:token:unlink', {
+                        ...envelope(),
+                        refs: [token.ref],
+                        frozen: freeze,
+                    });
+                }
+                return result.unlinked;
+            },
+        };
+    };
+    const planSetDisplay = (mode) => {
+        engine.configure({ display: mode });
+        const tokens = bound();
+        return planDisplayAll(tokens);
+    };
+    const runPlan = async (name, plan) => {
+        if (!plan.changed)
+            return plan.apply();
+        let applied = false;
+        const result = await host.transactions.run(name, (tx) => tx.mutate(() => {
+            const value = plan.apply();
+            applied = true;
+            return mutationOf(value, true);
+        }), { label: name });
+        void applied;
+        return result;
+    };
+    const caretTarget = () => {
+        const session = host.session;
+        if (session === undefined)
+            return undefined;
+        const resolved = session.resolve(host.selection.anchor);
+        if (resolved === undefined)
+            return undefined;
+        return { element: resolved.slot.element, offset: resolved.offset };
+    };
+    const tokenInside = (model, paragraph, offset) => tokenAncestorOf(paragraph) !== undefined ||
+        tokenAtOffset(model, paragraph, offset, bound()) !== undefined;
+    const tokenAtCaret = () => {
+        const session = host.session;
+        if (session === undefined)
+            return undefined;
+        const resolved = session.resolve(host.selection.anchor);
+        if (resolved === undefined)
+            return undefined;
+        const tokens = bound();
+        const at = tokenAtOffset(session.model, resolved.slot.element, resolved.offset, tokens);
+        if (at !== undefined)
+            return at;
+        const ancestor = tokenAncestorOf(resolved.slot.element);
+        if (ancestor === undefined)
+            return undefined;
+        return tokens.find((token) => token.element === ancestor);
+    };
+    const refill = async (mode) => {
+        const plan = await planFill(mode);
+        if (plan === undefined)
+            return EMPTY_SUMMARY;
+        const summary = await runPlan('Fill template', plan);
+        events.emit('docier:fill:after', { ...envelope(), mode, summary });
+        events.emit('docier:data:change', {
+            ...envelope(),
+            origin: 'user',
+            keys: Object.keys(engine.data()).sort(),
+            summary,
+        });
+        emitIssues();
+        for (const issue of summary.issues) {
+            if (issue.code !== 'unknown-token')
+                continue;
+            events.emit('docier:token:unknown', {
+                ...envelope(),
+                key: issue.key ?? '',
+                refs: issue.instances ?? [],
+            });
+        }
+        return summary;
+    };
+    engine.setFillRunner({
+        run: (request) => refill(request.mode),
+    });
+    const dataController = {
+        setData: async (data, setOptions) => {
+            await engine.setData(data, { ...setOptions, refill: false });
+            const summary = await refill('document');
+            events.emit('docier:data:change', {
+                ...envelope(),
+                origin: setOptions?.source ?? 'host',
+                keys: Object.keys(data).sort(),
+                summary,
+            });
+            return summary;
+        },
+        mergeData: async (patch, setOptions) => {
+            await engine.mergeData(patch, { ...setOptions, refill: false });
+            const summary = await refill('document');
+            events.emit('docier:data:change', {
+                ...envelope(),
+                origin: setOptions?.source ?? 'host',
+                keys: Object.keys(patch).sort(),
+                summary,
+            });
+            return summary;
+        },
+        getData: () => engine.data(),
+        clearData: () => {
+            engine.clearData();
+            engine.reportIssues([]);
+            emitIssues();
+        },
+        setDataSource: (next) => {
+            source = next ?? undefined;
+        },
+        refresh: async (paths) => {
+            if (source === undefined)
+                return refill('document');
+            const tokens = bound();
+            const requested = paths === undefined ? tokens.map((token) => token.ref.key) : [...paths];
+            const response = await source.load({
+                paths: requested,
+                loops: [],
+                locale: engine.options().locale,
+                documentId: host.config.document.docId,
+            }, new AbortController().signal);
+            return dataController.mergeData(response.values, { source: 'host' });
+        },
+        getIssues: (filter) => engine.issues().list(filter),
+        subscribeIssues: (listener) => engine.issues().subscribe(listener),
+        setPreview: async (next) => {
+            if (next === null || next.enabled !== true) {
+                preview = undefined;
+                const restore = datasetBeforePreview;
+                datasetBeforePreview = undefined;
+                if (restore === undefined)
+                    return;
+                await engine.setData(restore, { refill: false });
+                await refill('preview');
+                return;
+            }
+            if (preview === undefined)
+                datasetBeforePreview = engine.data();
+            preview = next;
+            engine.configure({ locale: next.locale ?? engine.options().locale });
+            await engine.setData(next.data ?? {}, { refill: false });
+            await refill('preview');
+        },
+    };
+    const controller = {
+        get catalogue() {
+            return engine.catalogue() ?? null;
+        },
+        data: dataController,
+        getIssues: (filter) => engine.issues().list(filter),
+        subscribeIssues: (listener) => engine.issues().subscribe(listener),
+        refs: () => instanceRefs(bound(), engine.index()),
+        resolve: (ref) => {
+            const value = engine.data()[ref.key];
+            if (value === undefined)
+                return undefined;
+            const rich = richKindOf(value);
+            if (rich !== undefined && rich !== 'text')
+                return value;
+            return {
+                kind: 'text',
+                text: plainTextOf(value, engine.index().entryOf(ref.key), {
+                    locale: engine.options().locale,
+                    fallbackLocale: engine.options().fallbackLocale,
+                }),
+            };
+        },
+        unlink: async (ref, unlinkOptions) => {
+            const refs = Array.isArray(ref) ? ref : [ref];
+            await runPlan('Unlink token', planUnlink(refs, unlinkOptions?.freeze ?? true));
+        },
+        fill: (fillOptions) => refill(fillOptions?.mode ?? 'document'),
+    };
+    const paletteFor = (text) => paletteOf(engine.index(), engine.options().locale, engine.options().fallbackLocale, { text });
+    const command = (spec) => ({
+        id: commandIdOf(spec.id),
+        label: spec.label,
+        category: spec.category,
+        layer: spec.layer ?? 'document',
+        undoable: spec.undoable ?? true,
+        repeatable: false,
+        ...(spec.description === undefined ? {} : { description: spec.description }),
+        ...(spec.disabledCode === undefined ? {} : { disabledCode: spec.disabledCode }),
+        invalidation: () => ({ kind: 'document' }),
+        isEnabled: (ctx) => enabled() && spec.available(ctx.args),
+        disabledReason: (ctx) => reasonOf() ?? spec.refuse(ctx.args),
+        execute: (args, ctx) => spec.run(args, ctx),
+    });
+    const declare = (ctx, value, changed) => ctx.mutate(() => mutationOf(value, changed));
+    const definitions = () => {
+        const commands = [];
+        const push = (spec) => {
+            commands.push(command(spec));
+        };
+        push({
+            id: 'docier.command.token.insert',
+            label: 'Insert token',
+            category: 'token',
+            description: 'Insert a catalogue token as a content control',
+            available: () => host.document !== undefined && !missingCatalogue(),
+            refuse: () => (host.document === undefined ? NO_DOCUMENT : INSIDE_TOKEN),
+            run: async (args, ctx) => {
+                if (args.key === undefined || args.key === '') {
+                    events.emit('docier:token:palette', {
+                        ...envelope(),
+                        sections: paletteFor(''),
+                        text: '',
+                    });
+                    return declare(ctx, false, false);
+                }
+                const entry = engine.index().entryOf(args.key);
+                if (entry === undefined)
+                    throw new CancelledChangeError(UNKNOWN_KEY(args.key));
+                return declare(ctx, planInsert(args.key, args.kind ?? entry.kind).apply(), true);
+            },
+        });
+        push({
+            id: 'docier.command.token.edit',
+            label: 'Edit token',
+            category: 'token',
+            available: () => host.document !== undefined && !missingCatalogue(),
+            refuse: () => (host.document === undefined ? NO_DOCUMENT : NO_TOKEN_HERE),
+            run: async (args, ctx) => {
+                const target = tokenAtCaret();
+                if (target === undefined)
+                    throw new CancelledChangeError(NO_TOKEN_HERE);
+                const entry = engine.index().entryOf(args.key);
+                if (entry === undefined)
+                    throw new CancelledChangeError(UNKNOWN_KEY(args.key));
+                const properties = childElements(target.element).find((child) => isWElement(child, 'sdtPr'));
+                const tag = properties === undefined
+                    ? undefined
+                    : childElements(properties).find((child) => isWElement(child, 'tag'));
+                if (tag === undefined)
+                    throw new CancelledChangeError(NO_TOKEN_HERE);
+                const attribute = tag.attributes?.find((candidate) => candidate.localName === 'val');
+                if (attribute === undefined)
+                    throw new CancelledChangeError(NO_TOKEN_HERE);
+                const previousKey = target.ref.key;
+                attribute.value = tokenTagOf(entry.kind, args.key);
+                events.emit('docier:token:change', {
+                    ...envelope(),
+                    ref: target.ref,
+                    key: args.key,
+                    previousKey,
+                });
+                return declare(ctx, true, true);
+            },
+        });
+        push({
+            id: 'docier.command.token.setValue',
+            label: 'Token value',
+            category: 'token',
+            available: () => host.document !== undefined,
+            refuse: () => (host.document === undefined ? NO_DOCUMENT : NO_TOKEN_HERE),
+            run: async (args, ctx) => {
+                const target = tokenAtCaret();
+                if (target === undefined)
+                    throw new CancelledChangeError(NO_TOKEN_HERE);
+                await engine.setData({ [target.ref.key]: args.value }, { mode: 'merge', refill: false });
+                const plan = await planFill('document');
+                if (plan !== undefined)
+                    plan.apply();
+                return declare(ctx, true, plan !== undefined);
+            },
+        });
+        push({
+            id: 'docier.command.token.update',
+            label: 'Update tokens',
+            category: 'token',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args, ctx) => {
+                void args;
+                const plan = await planFill('document');
+                if (plan === undefined)
+                    return declare(ctx, EMPTY_SUMMARY, false);
+                const summary = plan.apply();
+                emitIssues();
+                return declare(ctx, summary, true);
+            },
+        });
+        push({
+            id: 'docier.command.token.unlink',
+            label: 'Unlink token',
+            category: 'token',
+            available: () => host.document !== undefined,
+            refuse: () => (host.document === undefined ? NO_DOCUMENT : NO_TOKEN_HERE),
+            run: async (args, ctx) => {
+                void args;
+                const target = tokenAtCaret();
+                if (target === undefined)
+                    throw new CancelledChangeError(NO_TOKEN_HERE);
+                const plan = planUnlink([target.ref], true);
+                return declare(ctx, plan.apply() > 0, plan.changed);
+            },
+        });
+        push({
+            id: 'docier.command.token.toggleCodes',
+            label: 'Field codes',
+            category: 'token',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args, ctx) => {
+                void args;
+                const order = ['label', 'code', 'value'];
+                const at = order.indexOf(engine.options().display);
+                const next = order[(at + 1) % order.length] ?? 'label';
+                const plan = planSetDisplay(next);
+                plan.apply();
+                return declare(ctx, next, plan.changed);
+            },
+        });
+        push({
+            id: 'docier.command.token.palette',
+            label: 'Token palette',
+            category: 'token',
+            layer: 'chrome',
+            undoable: false,
+            available: () => !missingCatalogue(),
+            refuse: () => NO_CATALOGUE,
+            run: async (args) => {
+                const sections = paletteFor(args.text ?? '');
+                events.emit('docier:token:palette', {
+                    ...envelope(),
+                    sections,
+                    text: args.text ?? '',
+                });
+                return sections;
+            },
+        });
+        push({
+            id: 'docier.command.token.trigger',
+            label: 'Token autocomplete',
+            category: 'token',
+            layer: 'chrome',
+            undoable: false,
+            available: () => !missingCatalogue(),
+            refuse: () => NO_CATALOGUE,
+            run: async (args) => {
+                const results = paletteFor(args.query ?? '')
+                    .flatMap((section) => section.entries)
+                    .slice(0, 50);
+                events.emit('docier:token:trigger', {
+                    ...envelope(),
+                    query: args.query ?? '',
+                    results,
+                });
+                return results;
+            },
+        });
+        push({
+            id: 'docier.command.token.validate',
+            label: 'Validate tokens',
+            category: 'token',
+            layer: 'chrome',
+            undoable: false,
+            available: () => true,
+            refuse: () => NO_CATALOGUE,
+            run: async (args) => {
+                if (args.key !== undefined && args.key !== '' && !engine.index().has(args.key)) {
+                    const report = engine.unresolved(current(), 'any');
+                    const unknown = [
+                        issueOf('unknown-token', args.key, UNKNOWN_KEY(args.key), []),
+                    ];
+                    events.emit('docier:token:unresolved', {
+                        ...envelope(),
+                        ...report,
+                        keys: [args.key],
+                        issues: unknown,
+                        blocking: true,
+                    });
+                    return { ...report, keys: [args.key], issues: unknown, blocking: true };
+                }
+                const report = engine.unresolved(current(), 'any');
+                events.emit('docier:token:unresolved', { ...envelope(), ...report });
+                return report;
+            },
+        });
+        push({
+            id: 'docier.command.data.set',
+            label: 'Set data',
+            category: 'data',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args) => dataController.setData(args.data ?? {}, { source: 'host' }),
+        });
+        push({
+            id: 'docier.command.data.merge',
+            label: 'Merge data',
+            category: 'data',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args) => dataController.mergeData(args.patch ?? {}, { source: 'host' }),
+        });
+        push({
+            id: 'docier.command.data.clear',
+            label: 'Clear data',
+            category: 'data',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args, ctx) => {
+                void args;
+                dataController.clearData();
+                return declare(ctx, true, false);
+            },
+        });
+        push({
+            id: 'docier.command.data.refresh',
+            label: 'Refresh data',
+            category: 'data',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args) => dataController.refresh(args.paths),
+        });
+        push({
+            id: 'docier.command.data.preview',
+            label: 'Preview',
+            category: 'data',
+            available: () => host.document !== undefined,
+            refuse: () => NO_DOCUMENT,
+            run: async (args, ctx) => {
+                await dataController.setPreview(args.preview ?? null);
+                return declare(ctx, preview !== undefined, false);
+            },
+        });
+        push({
+            id: 'docier.command.export.unresolved',
+            label: 'Unresolved values',
+            category: 'export',
+            layer: 'chrome',
+            undoable: false,
+            available: () => true,
+            refuse: () => NO_CATALOGUE,
+            run: async (args) => {
+                const report = engine.unresolved(current(), args.target ?? 'any');
+                events.emit('docier:token:unresolved', { ...envelope(), ...report });
+                return report;
+            },
+        });
+        push({
+            id: 'docier.command.export.preflight',
+            label: 'Preflight export',
+            category: 'export',
+            layer: 'chrome',
+            undoable: false,
+            available: () => true,
+            refuse: () => NO_CATALOGUE,
+            run: async (args) => {
+                const target = args.target ?? 'docx';
+                const issues = engine.issues().list({ severities: ['error'] });
+                const gate = events.dispatch('docier:export:before', { ...envelope(), target, issues });
+                if (gate.defaultPrevented) {
+                    events.emit('docier:export:blocked', {
+                        ...envelope(),
+                        target,
+                        reason: 'An export listener cancelled the export',
+                        issues,
+                    });
+                    return false;
+                }
+                if (engine.options().issuePolicy === 'block' && issues.length > 0) {
+                    events.emit('docier:export:blocked', {
+                        ...envelope(),
+                        target,
+                        reason: 'The document still has unresolved tokens',
+                        issues,
+                    });
+                    return false;
+                }
+                return true;
+            },
+        });
+        return commands;
+    };
+    const install = () => {
+        if (!enabled()) {
+            registered = [];
+            return registered;
+        }
+        const ids = [];
+        for (const definition of definitions()) {
+            disposables.push(host.commands.replace(definition));
+            ids.push(definition.id);
+        }
+        registered = ids;
+        subscriptions.push(engine.issues().subscribe(() => emitIssues()));
+        return registered;
+    };
+    const uninstall = () => {
+        for (const disposable of disposables.splice(0))
+            disposable.dispose();
+        for (const unsubscribe of subscriptions.splice(0))
+            unsubscribe();
+        registered = [];
+    };
+    let registered = [];
+    install();
+    return {
+        id: host.id,
+        get enabled() {
+            return enabled();
+        },
+        get registered() {
+            return registered;
+        },
+        get reason() {
+            return registered.length === 0 ? reasonOf() : undefined;
+        },
+        engine,
+        data: dataController,
+        controller: () => controller,
+        install,
+        uninstall,
+        tokens: () => instanceRefs(bound(), engine.index()),
+        palette: (text) => paletteFor(text ?? ''),
+        trigger: (query) => paletteFor(query)
+            .flatMap((section) => section.entries)
+            .slice(0, 50),
+        refill: (fillOptions) => refill(fillOptions?.mode ?? 'document'),
+        unresolved: (target) => engine.unresolved(current(), target ?? 'any'),
+        insert: (key, kind) => {
+            const entry = engine.index().entryOf(key);
+            return Promise.resolve(planInsert(key, kind ?? entry?.kind ?? 'field').apply());
+        },
+        unlink: async (refs, unlinkOptions) => {
+            await runPlan('Unlink token', planUnlink(refs ?? [], unlinkOptions?.freeze ?? true));
+        },
+        setDisplay: async (mode) => {
+            await runPlan('Token display', planSetDisplay(mode));
+        },
+        dispose: () => {
+            uninstall();
+        },
+    };
+};
+export const issueOf = (code, key, detail, instances) => ({
+    code,
+    severity: SEVERITY_OF[code],
+    message: detail,
+    key,
+    detail,
+    instances,
+});
+export const TOKEN_COMMAND_IDS = [
+    'docier.command.token.insert',
+    'docier.command.token.edit',
+    'docier.command.token.setValue',
+    'docier.command.token.update',
+    'docier.command.token.unlink',
+    'docier.command.token.toggleCodes',
+    'docier.command.token.palette',
+    'docier.command.token.trigger',
+    'docier.command.token.validate',
+    'docier.command.data.set',
+    'docier.command.data.merge',
+    'docier.command.data.clear',
+    'docier.command.data.refresh',
+    'docier.command.data.preview',
+    'docier.command.export.unresolved',
+    'docier.command.export.preflight',
+];
+export const TOKEN_EVENT_NAMES = [
+    'docier:token:beforeinsert',
+    'docier:token:insert',
+    'docier:token:change',
+    'docier:token:remove',
+    'docier:token:unlink',
+    'docier:token:unknown',
+    'docier:token:trigger',
+    'docier:token:palette',
+    'docier:token:unresolved',
+    'docier:data:change',
+    'docier:fill:before',
+    'docier:fill:after',
+    'docier:export:before',
+    'docier:export:blocked',
+];
+//# sourceMappingURL=module.js.map