baseline-foundry 0.1.3

package/dist/build.js

@@ -0,0 +1,440 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { generateFoundryCss } from "./css.js";
+import { normalizeBuiltInThemeName, presetNames, resolveBuiltInThemePath, resolvePresetPath, resolveTierPath, tierNames } from "./presets.js";
+function parseRem(remValue) {
+    return Number.parseFloat(remValue.replace("rem", ""));
+}
+function roundRemValue(value) {
+    return Math.round(value * 100000) / 100000;
+}
+function toRem(value) {
+    return `${roundRemValue(value)}rem`;
+}
+async function ensureDirectory(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+async function emptyDirectory(dirPath) {
+    await ensureDirectory(dirPath);
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            await emptyDirectory(entryPath);
+            continue;
+        }
+        await fs.rm(entryPath, { recursive: true, force: true });
+    }
+}
+async function writeJsonFileAtomic(filePath, value) {
+    const tempFilePath = `${filePath}.tmp`;
+    await fs.writeFile(tempFilePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await fs.rm(filePath, { force: true });
+    await fs.rename(tempFilePath, filePath);
+}
+function assertFiniteNumberConfigField(value, fieldPath) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Theme config field "${fieldPath}" must be a finite number.`);
+    }
+}
+const REQUIRED_LAYOUT_FIELDS = [
+    "contentMaxWidthRem",
+    "contentPaddingInlineRem",
+    "measureRem",
+    "sectionSpaceBaselineUnits",
+    "sectionSpaceShallowBaselineUnits",
+    "sectionSpaceDeepBaselineUnits",
+    "stripSpaceBaselineUnits",
+    "gridGapInlineBaselineUnits",
+    "gridGapBlockBaselineUnits",
+    "pageMarginBaselineUnits"
+];
+const REQUIRED_COMPONENT_FIELDS = [
+    "borderWidthPx",
+    "radiusRem",
+    "controlBlockPaddingRem",
+    "controlInlinePaddingRem",
+    "controlVisualSizeRem",
+    "fieldGapBaselineUnits",
+    "panelPaddingInlineBaselineUnits",
+    "panelPaddingBlockBaselineUnits",
+    "accordionIndentBaselineUnits"
+];
+const OPTIONAL_COMPONENT_FIELDS = [
+    "controlCompactBlockPaddingRem",
+    "controlInlinePaddingActionRem",
+    "controlInlinePaddingFieldRem"
+];
+function assertNoDuplicateRoleKeys(raw, configPath) {
+    const rolesMatch = raw.match(/"roles"\s*:\s*\{([\s\S]*?)\}/);
+    if (!rolesMatch) {
+        throw new Error(`Theme config "${configPath}" requires a roles object.`);
+    }
+    const seen = new Set();
+    for (const match of rolesMatch[1].matchAll(/^\s*"([^"]+)"\s*:/gm)) {
+        const roleName = match[1];
+        if (seen.has(roleName)) {
+            throw new Error(`Theme config "${configPath}" contains duplicate role key "${roleName}".`);
+        }
+        seen.add(roleName);
+    }
+}
+function validateConfig(config) {
+    if (!config.fontFiles.length) {
+        throw new Error("Theme config requires at least one font file.");
+    }
+    if (!config.fontFiles.some(fontFile => !fontFile.runtimeOnly)) {
+        throw new Error("Theme config requires at least one build-time font file.");
+    }
+    if (!config.elements.length) {
+        throw new Error("Theme config requires at least one typography element.");
+    }
+    if (!config.roles.body) {
+        throw new Error('Theme config requires a "body" role.');
+    }
+    if (!config.components) {
+        throw new Error("Theme config requires a components block.");
+    }
+    assertFiniteNumberConfigField(config.baselineUnit, "baselineUnit");
+    if (config.baselineUnit <= 0) {
+        throw new Error('Theme config field "baselineUnit" must be greater than zero.');
+    }
+    for (const field of REQUIRED_LAYOUT_FIELDS) {
+        assertFiniteNumberConfigField(config.layout[field], `layout.${field}`);
+    }
+    for (const field of REQUIRED_COMPONENT_FIELDS) {
+        assertFiniteNumberConfigField(config.components[field], `components.${field}`);
+    }
+    for (const field of OPTIONAL_COMPONENT_FIELDS) {
+        const value = config.components[field];
+        if (value !== undefined) {
+            assertFiniteNumberConfigField(value, `components.${field}`);
+        }
+    }
+    const elementIdentifiers = new Set();
+    for (const [index, element] of config.elements.entries()) {
+        if (elementIdentifiers.has(element.identifier)) {
+            throw new Error(`Theme config contains duplicate element identifier "${element.identifier}".`);
+        }
+        elementIdentifiers.add(element.identifier);
+        assertFiniteNumberConfigField(element.fontSize, `elements[${index}].fontSize`);
+        assertFiniteNumberConfigField(element.lineHeight, `elements[${index}].lineHeight`);
+        assertFiniteNumberConfigField(element.spaceAfter, `elements[${index}].spaceAfter`);
+        if (element.fontWeight !== undefined) {
+            assertFiniteNumberConfigField(element.fontWeight, `elements[${index}].fontWeight`);
+        }
+        if (element.fontSize <= 0 || element.lineHeight <= 0) {
+            throw new Error(`Theme element "${element.identifier}" requires positive fontSize and lineHeight values.`);
+        }
+        if (element.spaceAfter < 1) {
+            throw new Error(`Theme element "${element.identifier}" requires spaceAfter >= 1 baseline unit so semantic margin is non-negative.`);
+        }
+    }
+    for (const [roleName, identifier] of Object.entries(config.roles)) {
+        if (!elementIdentifiers.has(identifier)) {
+            throw new Error(`Role "${roleName}" points to missing element "${identifier}".`);
+        }
+    }
+}
+export async function readThemeConfig(configPath) {
+    const raw = await fs.readFile(configPath, "utf8");
+    assertNoDuplicateRoleKeys(raw, configPath);
+    const config = JSON.parse(raw);
+    validateConfig(config);
+    return config;
+}
+function createBaselineConfig(config, sourceConfigPath, baselineConfigPath) {
+    const sourceConfigDir = path.dirname(sourceConfigPath);
+    const baselineConfigDir = path.dirname(baselineConfigPath);
+    return {
+        baselineUnit: config.baselineUnit,
+        fontFiles: config.fontFiles.filter(fontFile => !fontFile.runtimeOnly).map(fontFile => {
+            const absoluteFontPath = path.resolve(sourceConfigDir, fontFile.path);
+            const relativeFontPath = path.relative(baselineConfigDir, absoluteFontPath).replace(/\\/g, "/");
+            return {
+                family: fontFile.family,
+                path: relativeFontPath
+            };
+        }),
+        elements: config.elements.map((element) => ({
+            identifier: element.identifier,
+            fontSize: element.fontSize,
+            lineHeight: element.lineHeight,
+            spaceAfter: element.spaceAfter,
+            fontFamily: element.fontFamily,
+            fontWeight: element.fontWeight,
+            fontStyle: element.fontStyle
+        }))
+    };
+}
+function createRuntimeFontFiles(config, sourceConfigPath, outputDir) {
+    const sourceConfigDir = path.dirname(sourceConfigPath);
+    return config.fontFiles.map(fontFile => {
+        const absoluteFontPath = path.resolve(sourceConfigDir, fontFile.path);
+        const relativeFontPath = path.relative(outputDir, absoluteFontPath).replace(/\\/g, "/");
+        return {
+            ...fontFile,
+            path: relativeFontPath
+        };
+    });
+}
+async function generateBaselineTokens(baselineConfigPath, outputDir) {
+    const moduleNamespace = await import("@lyubomir-popov/baseline-nudge-generator");
+    const generateFromConfig = (moduleNamespace.generateFromConfig ?? moduleNamespace.default?.generateFromConfig);
+    if (!generateFromConfig) {
+        throw new Error("Unable to load generateFromConfig from @lyubomir-popov/baseline-nudge-generator.");
+    }
+    await generateFromConfig(baselineConfigPath, outputDir);
+    const tokensPath = path.join(outputDir, "tokens.json");
+    const raw = await fs.readFile(tokensPath, "utf8");
+    return JSON.parse(raw);
+}
+function toTypographyToken(identifier, token, config) {
+    const elementConfig = config.elements.find(element => element.identifier === identifier);
+    const fontFamily = token.fontFamily ?? config.fontFiles[0]?.family ?? "sans";
+    const fontStack = config.fontStacks[fontFamily] ?? fontFamily;
+    const marginBottom = toRem(config.baselineUnit - parseRem(token.nudgeTop));
+    return {
+        ...token,
+        identifier,
+        fontFamily,
+        fontStack,
+        marginBottom,
+        fontVariantCaps: elementConfig?.fontVariantCaps,
+        letterSpacing: elementConfig?.letterSpacing,
+        textTransform: elementConfig?.textTransform
+    };
+}
+function buildComponentTokens(config) {
+    const controlInlinePaddingActionRem = config.components.controlInlinePaddingActionRem ?? config.components.controlInlinePaddingRem;
+    const controlInlinePaddingFieldRem = config.components.controlInlinePaddingFieldRem ?? (controlInlinePaddingActionRem / 2);
+    return {
+        borderWidth: `${config.components.borderWidthPx}px`,
+        // Vanilla's shared $bar-thickness: 3px at a 16px root, expressed in rem
+        // so emphasis bars scale with root text sizing while thin borders do not.
+        barThickness: toRem(3 / 16),
+        radius: toRem(config.components.radiusRem),
+        controlBlockPadding: toRem(config.components.controlBlockPaddingRem),
+        controlCompactBlockPadding: toRem(config.components.controlCompactBlockPaddingRem ?? config.components.controlBlockPaddingRem),
+        controlInlinePadding: toRem(controlInlinePaddingActionRem),
+        controlInlinePaddingAction: toRem(controlInlinePaddingActionRem),
+        controlInlinePaddingField: toRem(controlInlinePaddingFieldRem),
+        controlVisualSize: toRem(config.components.controlVisualSizeRem),
+        fieldGap: toRem(config.components.fieldGapBaselineUnits * config.baselineUnit),
+        panelPaddingInline: toRem(config.components.panelPaddingInlineBaselineUnits * config.baselineUnit),
+        panelPaddingBlock: toRem(config.components.panelPaddingBlockBaselineUnits * config.baselineUnit),
+        accordionIndent: toRem(config.components.accordionIndentBaselineUnits * config.baselineUnit)
+    };
+}
+function buildThemeTokens(config, baselineTokens) {
+    const elements = Object.fromEntries(Object.entries(baselineTokens.elements).map(([identifier, token]) => [identifier, toTypographyToken(identifier, token, config)]));
+    const roles = Object.fromEntries(Object.entries(config.roles).map(([roleName, identifier]) => {
+        const roleToken = elements[identifier];
+        if (!roleToken) {
+            throw new Error(`Missing generated token for role "${roleName}" / identifier "${identifier}".`);
+        }
+        return [roleName, roleToken];
+    }));
+    return {
+        baselineUnit: baselineTokens.baselineUnit,
+        fontFiles: config.fontFiles,
+        fontStacks: config.fontStacks,
+        roles,
+        elements,
+        layout: {
+            contentMaxWidth: toRem(config.layout.contentMaxWidthRem),
+            contentPaddingInline: toRem(config.layout.contentPaddingInlineRem),
+            measure: toRem(config.layout.measureRem),
+            sectionSpace: toRem(config.layout.sectionSpaceBaselineUnits * config.baselineUnit),
+            sectionSpaceShallow: toRem(config.layout.sectionSpaceShallowBaselineUnits * config.baselineUnit),
+            sectionSpaceDeep: toRem(config.layout.sectionSpaceDeepBaselineUnits * config.baselineUnit),
+            stripSpace: toRem(config.layout.stripSpaceBaselineUnits * config.baselineUnit),
+            gridGapInline: toRem(config.layout.gridGapInlineBaselineUnits * config.baselineUnit),
+            gridGapBlock: toRem(config.layout.gridGapBlockBaselineUnits * config.baselineUnit),
+            pageMargin: toRem(config.layout.pageMarginBaselineUnits * config.baselineUnit)
+        },
+        components: buildComponentTokens(config)
+    };
+}
+function inferBuiltInPresetName(resolvedConfigPath) {
+    for (const tierName of tierNames) {
+        if (resolvedConfigPath === resolveTierPath(tierName)) {
+            return tierName;
+        }
+    }
+    for (const presetName of presetNames) {
+        if (resolvedConfigPath === resolveBuiltInThemePath(presetName)) {
+            return presetName;
+        }
+    }
+    return undefined;
+}
+function inferSurfaceName(resolvedConfigPath) {
+    const builtInName = inferBuiltInPresetName(resolvedConfigPath);
+    if (builtInName) {
+        return normalizeBuiltInThemeName(builtInName);
+    }
+    return path.parse(resolvedConfigPath).name;
+}
+function surfaceClassName(surfaceName) {
+    return tierNames.includes(surfaceName) ? `bf-tier-${surfaceName}` : undefined;
+}
+function runtimeMetricsTokens(baselineTokens, runtimeFontFiles) {
+    const metricFamilies = new Set(Object.values(baselineTokens.elements)
+        .map(token => token.fontFamily)
+        .filter((family) => typeof family === "string"));
+    return {
+        ...baselineTokens,
+        fontFiles: runtimeFontFiles
+            .filter(fontFile => !fontFile.runtimeOnly)
+            .filter(fontFile => metricFamilies.size === 0 || metricFamilies.has(fontFile.family))
+            .map(fontFile => ({ ...fontFile }))
+    };
+}
+function buildSurfaceManifest(defaultSurface, surfaces) {
+    return {
+        defaultSurface,
+        surfaces: Object.fromEntries(surfaces.map(surface => [surface.name, {
+                label: surface.label,
+                className: surface.className,
+                engine: surface.engine,
+                tokens: surface.tokens,
+                metrics: surface.metrics
+            }]))
+    };
+}
+async function buildThemeSurface(name, resolvedConfigPath, baselineDir, outputDir, options = {}) {
+    const config = await readThemeConfig(resolvedConfigPath);
+    const resolvedBaselineDir = path.resolve(baselineDir);
+    const resolvedOutputDir = path.resolve(outputDir);
+    await ensureDirectory(resolvedBaselineDir);
+    const baselineConfigFileName = `${path.parse(resolvedConfigPath).name}.baseline.json`;
+    const baselineConfigPath = path.join(resolvedBaselineDir, baselineConfigFileName);
+    await writeJsonFileAtomic(baselineConfigPath, createBaselineConfig(config, resolvedConfigPath, baselineConfigPath));
+    const baselineTokens = await generateBaselineTokens(baselineConfigPath, resolvedBaselineDir);
+    const runtimeConfig = {
+        ...config,
+        fontFiles: createRuntimeFontFiles(config, resolvedConfigPath, resolvedOutputDir)
+    };
+    return {
+        name,
+        label: options.label,
+        className: options.className,
+        engine: options.engine ?? "metrics-compensated",
+        configPath: resolvedConfigPath,
+        baselineConfigPath,
+        baselineTokensPath: path.join(resolvedBaselineDir, "tokens.json"),
+        tokens: buildThemeTokens(runtimeConfig, baselineTokens),
+        metrics: runtimeMetricsTokens(baselineTokens, runtimeConfig.fontFiles)
+    };
+}
+async function buildRelatedTierSurfaces(resolvedConfigPath, currentSurfaceName, baselineDir, outputDir) {
+    if (!inferBuiltInPresetName(resolvedConfigPath)) {
+        return [];
+    }
+    const surfaces = [];
+    for (const tierName of tierNames) {
+        if (tierName === currentSurfaceName) {
+            continue;
+        }
+        surfaces.push(await buildThemeSurface(tierName, resolveTierPath(tierName), path.join(baselineDir, "surfaces", tierName), outputDir, {
+            className: `bf-tier-${tierName}`
+        }));
+    }
+    return surfaces;
+}
+async function buildAdditionalThemeSurfaces(surfaceConfigs, baselineDir, outputDir) {
+    const surfaces = [];
+    for (const surfaceConfig of surfaceConfigs) {
+        surfaces.push(await buildThemeSurface(surfaceConfig.name, path.resolve(surfaceConfig.configPath), path.join(baselineDir, "surfaces", surfaceConfig.name), outputDir, {
+            className: surfaceConfig.className,
+            label: surfaceConfig.label
+        }));
+    }
+    return surfaces;
+}
+function assertUniqueSurfaceNames(surfaces) {
+    const names = new Set();
+    for (const surface of surfaces) {
+        if (names.has(surface.name)) {
+            throw new Error(`Duplicate surface name "${surface.name}" in build output.`);
+        }
+        names.add(surface.name);
+    }
+}
+async function buildTheme(resolvedConfigPath, distDir, baselineDir, options = {}) {
+    const resolvedDistDir = path.resolve(distDir);
+    const resolvedBaselineDir = path.resolve(baselineDir);
+    await ensureDirectory(resolvedDistDir);
+    await emptyDirectory(resolvedBaselineDir);
+    const builtInName = inferBuiltInPresetName(resolvedConfigPath);
+    const defaultSurfaceName = inferSurfaceName(resolvedConfigPath);
+    const defaultSurface = await buildThemeSurface(defaultSurfaceName, resolvedConfigPath, resolvedBaselineDir, resolvedDistDir, {
+        label: options.surfaceLabel,
+        className: surfaceClassName(defaultSurfaceName)
+    });
+    const relatedSurfaces = await buildRelatedTierSurfaces(resolvedConfigPath, defaultSurfaceName, resolvedBaselineDir, resolvedDistDir);
+    const additionalSurfaces = await buildAdditionalThemeSurfaces(options.additionalSurfaces ?? [], resolvedBaselineDir, resolvedDistDir);
+    const surfaces = [defaultSurface, ...relatedSurfaces, ...additionalSurfaces];
+    assertUniqueSurfaceNames(surfaces);
+    const surfaceManifest = buildSurfaceManifest(defaultSurfaceName, surfaces);
+    const css = generateFoundryCss(defaultSurface.tokens, {
+        presetName: builtInName,
+        themeSurfaces: surfaces.filter(surface => surface.className)
+    });
+    const tokensPath = path.join(resolvedDistDir, "tokens.json");
+    const cssPath = path.join(resolvedDistDir, "styles.css");
+    const surfaceManifestPath = path.join(resolvedDistDir, "surfaces.json");
+    await fs.writeFile(tokensPath, `${JSON.stringify(defaultSurface.tokens, null, 2)}\n`, "utf8");
+    await fs.writeFile(cssPath, css, "utf8");
+    await fs.writeFile(surfaceManifestPath, `${JSON.stringify(surfaceManifest, null, 2)}\n`, "utf8");
+    return {
+        configPath: resolvedConfigPath,
+        baselineConfigPath: defaultSurface.baselineConfigPath,
+        baselineTokensPath: defaultSurface.baselineTokensPath,
+        tokensPath,
+        cssPath,
+        surfaceManifestPath,
+        tokens: defaultSurface.tokens,
+        css,
+        surfaces: surfaceManifest
+    };
+}
+export async function buildThemeFromConfig(configPath = path.resolve("config/tiers/editorial.json"), options = {}) {
+    const resolvedConfigPath = path.resolve(configPath);
+    const distDir = options.distDir ?? "dist";
+    const baselineDir = options.baselineDir ?? "generated/baseline";
+    return buildTheme(resolvedConfigPath, distDir, baselineDir, {
+        surfaceLabel: options.surfaceLabel,
+        additionalSurfaces: options.additionalSurfaces
+    });
+}
+export async function buildThemeFromTier(tier) {
+    return buildThemeFromConfig(resolveTierPath(tier), {
+        distDir: path.join("dist", "tiers", tier),
+        baselineDir: path.join("generated", "baseline", "tiers", tier)
+    });
+}
+export async function buildThemeFromPreset(preset) {
+    return buildThemeFromConfig(resolvePresetPath(preset), {
+        distDir: path.join("dist", "presets", preset),
+        baselineDir: path.join("generated", "baseline", preset)
+    });
+}
+export async function deriveBaselineTokensFromConfig(configPath = path.resolve("config/tiers/editorial.json"), options = {}) {
+    const resolvedConfigPath = path.resolve(configPath);
+    const baselineDir = options.baselineDir ?? "generated/baseline";
+    const resolvedBaselineDir = path.resolve(baselineDir);
+    await emptyDirectory(resolvedBaselineDir);
+    const config = await readThemeConfig(resolvedConfigPath);
+    const baselineConfigFileName = `${path.parse(resolvedConfigPath).name}.baseline.json`;
+    const baselineConfigPath = path.join(resolvedBaselineDir, baselineConfigFileName);
+    await writeJsonFileAtomic(baselineConfigPath, createBaselineConfig(config, resolvedConfigPath, baselineConfigPath));
+    const tokens = await generateBaselineTokens(baselineConfigPath, resolvedBaselineDir);
+    return {
+        configPath: resolvedConfigPath,
+        baselineConfigPath,
+        baselineTokensPath: path.join(resolvedBaselineDir, "tokens.json"),
+        tokens
+    };
+}

package/dist/code-snippet.d.ts

@@ -0,0 +1,6 @@
+export interface CodeSnippetInitOptions {
+    root?: ParentNode;
+    copiedLabel?: string;
+    copiedDurationMs?: number;
+}
+export declare function initCodeSnippets(options?: CodeSnippetInitOptions): () => void;

package/dist/code-snippet.js

@@ -0,0 +1,95 @@
+const COPY_SELECTOR = ".bf-code-snippet-block.is-icon";
+function getCopyBlock(target) {
+    if (!(target instanceof Element)) {
+        return null;
+    }
+    return target.closest(COPY_SELECTOR);
+}
+async function copySnippetText(copyBlock) {
+    const text = copyBlock.textContent?.trim() ?? "";
+    if (!text) {
+        return false;
+    }
+    try {
+        if (navigator.clipboard?.writeText) {
+            await navigator.clipboard.writeText(text);
+            return true;
+        }
+    }
+    catch {
+        // Fall through to the legacy command path.
+    }
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.setAttribute("readonly", "");
+    textarea.style.position = "fixed";
+    textarea.style.inset = "-9999px";
+    document.body.append(textarea);
+    textarea.select();
+    try {
+        return document.execCommand("copy");
+    }
+    catch {
+        return false;
+    }
+    finally {
+        textarea.remove();
+    }
+}
+function markCopied(copyBlock, copiedLabel, copiedDurationMs) {
+    const originalTitle = copyBlock.getAttribute("title");
+    const existingTimer = Number.parseInt(copyBlock.dataset.bfCopiedTimer ?? "", 10);
+    if (Number.isFinite(existingTimer)) {
+        window.clearTimeout(existingTimer);
+    }
+    copyBlock.classList.add("is-copied");
+    copyBlock.setAttribute("title", copiedLabel);
+    const timer = window.setTimeout(() => {
+        copyBlock.classList.remove("is-copied");
+        if (originalTitle) {
+            copyBlock.setAttribute("title", originalTitle);
+        }
+        else {
+            copyBlock.removeAttribute("title");
+        }
+        delete copyBlock.dataset.bfCopiedTimer;
+    }, copiedDurationMs);
+    copyBlock.dataset.bfCopiedTimer = String(timer);
+}
+export function initCodeSnippets(options = {}) {
+    const root = options.root ?? document;
+    const copiedLabel = options.copiedLabel ?? "Copied";
+    const copiedDurationMs = options.copiedDurationMs ?? 2000;
+    const handleCopy = async (event) => {
+        const copyBlock = getCopyBlock(event.target);
+        if (!copyBlock) {
+            return;
+        }
+        const copied = await copySnippetText(copyBlock);
+        if (copied) {
+            markCopied(copyBlock, copiedLabel, copiedDurationMs);
+        }
+    };
+    const onClick = (event) => {
+        void handleCopy(event);
+    };
+    const onKeyDown = (event) => {
+        if (!(event instanceof KeyboardEvent)) {
+            return;
+        }
+        const copyBlock = getCopyBlock(event.target);
+        if (!copyBlock) {
+            return;
+        }
+        if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            void handleCopy(event);
+        }
+    };
+    root.addEventListener("click", onClick);
+    root.addEventListener("keydown", onKeyDown);
+    return () => {
+        root.removeEventListener("click", onClick);
+        root.removeEventListener("keydown", onKeyDown);
+    };
+}

package/dist/contextual-menu.d.ts

@@ -0,0 +1,4 @@
+export interface ContextualMenuInitOptions {
+    root?: ParentNode;
+}
+export declare function initContextualMenus(options?: ContextualMenuInitOptions): () => void;