@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/furnace-config.js

@@ -1,511 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { FURNACE_PENDING_REPAIR_OPERATIONS } from '../types/furnace.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, readJson, writeJson } from '../utils/fs.js';
-import { warn } from '../utils/logger.js';
-import { isObject, isString } from '../utils/validation.js';
-import { FIREFORGE_DIR } from './config.js';
-import { parseStringArray } from './furnace-config-array-utils.js';
-import { parseCustomConfig } from './furnace-config-custom.js';
-import { orderFurnaceConfigForWrite } from './furnace-config-order.js';
-import { validateRuntimeVariables, validateTokenHostDocuments } from './furnace-config-tokens.js';
-import { applyOptionalFurnaceFields, parseNamedComponentMap, parseOverrideConfig, parseStockList, } from './furnace-config-validate.js';
-import { resolveFtlDir } from './furnace-constants.js';
-import { detectComposesCycles, validateComposesReferences } from './furnace-graph-utils.js';
-import { quarantineStateFile, withStateFileLock } from './state-file.js';
-export { detectComposesCycles };
-/** Name of the furnace configuration file */
-const FURNACE_CONFIG_FILENAME = 'furnace.json';
-/** Name of the furnace state file */
-const FURNACE_STATE_FILENAME = 'furnace-state.json';
-/** Name of the components directory */
-const COMPONENTS_DIR = 'components';
-/** Name of the overrides subdirectory */
-const OVERRIDES_DIR = 'overrides';
-/** Name of the custom subdirectory */
-const CUSTOM_DIR = 'custom';
-/** Directory name for shared CSS fragments within components/ */
-export const SHARED_FRAGMENTS_DIR = 'shared';
-/**
- * Gets all furnace-related paths based on a root directory.
- * @param root - Root directory of the project
- * @returns All furnace paths
- */
-export function getFurnacePaths(root) {
-    const componentsDir = join(root, COMPONENTS_DIR);
-    return {
-        furnaceConfig: join(root, FURNACE_CONFIG_FILENAME),
-        componentsDir,
-        overridesDir: join(componentsDir, OVERRIDES_DIR),
-        customDir: join(componentsDir, CUSTOM_DIR),
-        sharedDir: join(componentsDir, SHARED_FRAGMENTS_DIR),
-        furnaceState: join(root, FIREFORGE_DIR, FURNACE_STATE_FILENAME),
-    };
-}
-/**
- * Checks if a furnace.json exists in the given directory.
- * @param root - Root directory to check
- * @returns True if furnace.json exists
- */
-export async function furnaceConfigExists(root) {
-    const paths = getFurnacePaths(root);
-    return pathExists(paths.furnaceConfig);
-}
-/** True when a recovered record carries at least one entry. */
-function hasEntries(record) {
-    return Object.keys(record).length > 0;
-}
-/** The current (and only) config schema version. */
-const CURRENT_CONFIG_VERSION = 1;
-/**
- * Rejects a config whose `version` field is not the single schema version that
- * exists. A non-integer or sub-1 value is a malformed document. A value above
- * the current version was written by a newer FireForge and cannot be read here.
- */
-function validateConfigVersion(version) {
-    if (typeof version !== 'number' || !Number.isInteger(version) || version < 1) {
-        throw new FurnaceError(`Furnace config: "version" must be a positive integer (got ${JSON.stringify(version)}). ` +
-            `Current schema version is ${CURRENT_CONFIG_VERSION}.`);
-    }
-    if (version > CURRENT_CONFIG_VERSION) {
-        throw new FurnaceError(`Furnace config: version ${version} is newer than what this version of FireForge supports (${CURRENT_CONFIG_VERSION}). ` +
-            'Upgrade FireForge to read this config.');
-    }
-}
-/**
- * Validates a raw config object and returns a typed FurnaceConfig.
- * @param data - Raw data to validate
- * @returns Validated FurnaceConfig
- * @throws Error if validation fails
- */
-export function validateFurnaceConfig(data) {
-    if (!isObject(data)) {
-        throw new FurnaceError('Furnace config must be an object');
-    }
-    // Furnace config documents arrive from JSON.parse (loadFurnaceConfig /
-    // writeFurnaceConfig round-trips), which can only produce JSON values,
-    // so the object check above is the only invariant left to establish.
-    const raw = data;
-    validateConfigVersion(raw['version']);
-    if (!isString(raw['componentPrefix'])) {
-        throw new FurnaceError('Furnace config: "componentPrefix" must be a string');
-    }
-    // Validate optional tokenPrefix
-    if (raw['tokenPrefix'] !== undefined && !isString(raw['tokenPrefix'])) {
-        throw new FurnaceError('Furnace config: "tokenPrefix" must be a string if provided');
-    }
-    // Validate optional tokenAllowlist
-    if (raw['tokenAllowlist'] !== undefined) {
-        parseStringArray(raw['tokenAllowlist'], 'tokenAllowlist');
-    }
-    // Validate optional runtimeVariables: CSS runtime state channels
-    // (e.g. `--cam-x`) that are exempt from `token-prefix-violation`.
-    validateRuntimeVariables(raw['runtimeVariables']);
-    // Validate optional tokenHostDocuments: list of chrome XHTMLs that the
-    // `missing-token-link` validator scans for the tokens CSS link.
-    validateTokenHostDocuments(raw['tokenHostDocuments']);
-    const stock = parseStockList(raw['stock']);
-    const overrides = parseNamedComponentMap(raw['overrides'], 'override', 'overrides', parseOverrideConfig);
-    const custom = parseNamedComponentMap(raw['custom'], 'custom', 'custom', parseCustomConfig);
-    // Detect circular composes references among custom components.
-    detectComposesCycles(custom);
-    // Validate that every composes reference points to a known component.
-    validateComposesReferences(stock, overrides, custom);
-    // Warn when two custom components share a targetPath. Nothing technically
-    // prevents co-location, but per-component removal and orphan detection
-    // both reason about "files this component deployed into its directory".
-    // Shared directories make those judgements ambiguous, and can lead to
-    // `furnace remove` of one component deleting the other's deployed files.
-    const targetPathOwners = new Map();
-    for (const [name, custom_] of Object.entries(custom)) {
-        const owners = targetPathOwners.get(custom_.targetPath) ?? [];
-        owners.push(name);
-        targetPathOwners.set(custom_.targetPath, owners);
-    }
-    for (const [targetPath, owners] of targetPathOwners) {
-        if (owners.length > 1) {
-            warn(`furnace.json: custom components ${owners.join(', ')} share targetPath "${targetPath}". ` +
-                'Give each component its own directory — shared directories make per-component ' +
-                'removal and drift detection ambiguous.');
-        }
-    }
-    const config = {
-        version: CURRENT_CONFIG_VERSION,
-        componentPrefix: raw['componentPrefix'],
-        stock,
-        overrides,
-        custom,
-    };
-    applyOptionalFurnaceFields(raw, config);
-    return config;
-}
-/**
- * Validates a parsed furnace state object and returns a typed FurnaceState.
- * @param data - Parsed JSON state data
- * @returns Validated FurnaceState
- */
-function validateFurnaceState(data) {
-    const result = sanitizeFurnaceState(data);
-    if (result.issues.length > 0) {
-        throw new FurnaceError(`Invalid furnace state: ${result.issues.join('; ')}`);
-    }
-    return result.state;
-}
-// Single source of truth: the list the union is derived from. The copy
-// this replaced was annotated rather than linked, so it caught a member
-// removed from the union but never one added to it, and listed them in a
-// different order.
-const PENDING_REPAIR_OPERATIONS = FURNACE_PENDING_REPAIR_OPERATIONS;
-function parsePendingRepair(data) {
-    if (!isObject(data)) {
-        return { error: 'field "pendingRepair" must be an object' };
-    }
-    if (!isString(data['operation']) ||
-        !PENDING_REPAIR_OPERATIONS.includes(data['operation'])) {
-        return {
-            error: `pendingRepair.operation must be one of: ${PENDING_REPAIR_OPERATIONS.join(', ')}`,
-        };
-    }
-    if (!isString(data['timestamp'])) {
-        return { error: 'pendingRepair.timestamp must be a string' };
-    }
-    if (!isString(data['reason'])) {
-        return { error: 'pendingRepair.reason must be a string' };
-    }
-    return {
-        operation: data['operation'],
-        timestamp: data['timestamp'],
-        reason: data['reason'],
-    };
-}
-function sanitizeFurnaceState(data) {
-    if (!isObject(data)) {
-        return {
-            state: {},
-            issues: ['the root value must be a JSON object'],
-            recoveredFields: [],
-        };
-    }
-    const state = {};
-    const issues = [];
-    const recoveredFields = [];
-    if (data['lastApply'] !== undefined) {
-        if (!isString(data['lastApply'])) {
-            issues.push('field "lastApply" must be a string');
-        }
-        else {
-            state.lastApply = data['lastApply'];
-            recoveredFields.push('lastApply');
-        }
-    }
-    if (data['appliedChecksums'] !== undefined) {
-        if (!isObject(data['appliedChecksums'])) {
-            issues.push('field "appliedChecksums" must be an object of string checksum values');
-        }
-        else {
-            const appliedChecksums = {};
-            let hasInvalidChecksum = false;
-            for (const [filePath, checksum] of Object.entries(data['appliedChecksums'])) {
-                if (!isString(checksum)) {
-                    hasInvalidChecksum = true;
-                    issues.push(`appliedChecksums["${filePath}"] must be a string`);
-                    continue;
-                }
-                appliedChecksums[filePath] = checksum;
-            }
-            if (hasEntries(appliedChecksums) || !hasInvalidChecksum) {
-                state.appliedChecksums = appliedChecksums;
-                recoveredFields.push('appliedChecksums');
-            }
-        }
-    }
-    if (data['engineChecksums'] !== undefined) {
-        if (!isObject(data['engineChecksums'])) {
-            issues.push('field "engineChecksums" must be an object of string checksum values');
-        }
-        else {
-            const engineChecksums = {};
-            for (const [filePath, checksum] of Object.entries(data['engineChecksums'])) {
-                if (isString(checksum)) {
-                    engineChecksums[filePath] = checksum;
-                }
-            }
-            if (hasEntries(engineChecksums)) {
-                state.engineChecksums = engineChecksums;
-                recoveredFields.push('engineChecksums');
-            }
-        }
-    }
-    if (data['pendingRepair'] !== undefined) {
-        const parsed = parsePendingRepair(data['pendingRepair']);
-        if ('error' in parsed) {
-            issues.push(parsed.error);
-        }
-        else {
-            state.pendingRepair = parsed;
-            recoveredFields.push('pendingRepair');
-        }
-    }
-    return { state, issues, recoveredFields };
-}
-async function recoverInvalidFurnaceState(statePath, result, alreadyLocked = false) {
-    const recover = async () => {
-        const quarantinedFile = await quarantineStateFile(statePath, 'invalid');
-        if (result.recoveredFields.length > 0) {
-            await writeJson(statePath, result.state);
-        }
-        const recoveryMessage = result.recoveredFields.length > 0
-            ? ` Recovered valid field${result.recoveredFields.length === 1 ? '' : 's'}: ${result.recoveredFields.join(', ')}.`
-            : ' No valid furnace state fields could be recovered; using defaults.';
-        const quarantineMessage = quarantinedFile
-            ? ` Quarantined the original file as ${quarantinedFile}.`
-            : '';
-        warn(`Furnace state file (.fireforge/furnace-state.json) was invalid: ${result.issues.join('; ')}.${recoveryMessage}${quarantineMessage}`);
-        return result.state;
-    };
-    return alreadyLocked ? recover() : withStateFileLock(statePath, recover);
-}
-async function loadFurnaceStateFromPath(statePath, alreadyLocked = false) {
-    if (!(await pathExists(statePath))) {
-        return {};
-    }
-    try {
-        const data = await readJson(statePath);
-        const result = sanitizeFurnaceState(data);
-        if (result.issues.length === 0) {
-            return result.state;
-        }
-        return await recoverInvalidFurnaceState(statePath, result, alreadyLocked);
-    }
-    catch (error) {
-        return await recoverInvalidFurnaceState(statePath, {
-            state: {},
-            issues: [`the file could not be parsed: ${toError(error).message}`],
-            recoveredFields: [],
-        }, alreadyLocked);
-    }
-}
-/**
- * Loads and validates the furnace.json configuration.
- * @param root - Root directory of the project
- * @returns Validated FurnaceConfig
- * @throws Error if config doesn't exist or is invalid
- */
-export async function loadFurnaceConfig(root) {
-    const paths = getFurnacePaths(root);
-    if (!(await pathExists(paths.furnaceConfig))) {
-        throw new FurnaceError(`Furnace configuration file not found: ${paths.furnaceConfig}\n\n` +
-            'Run "fireforge furnace create" or "fireforge furnace override" to get started.');
-    }
-    try {
-        const data = await readJson(paths.furnaceConfig);
-        return validateFurnaceConfig(data);
-    }
-    catch (error) {
-        if (error instanceof FurnaceError) {
-            throw error;
-        }
-        throw new FurnaceError(`Invalid furnace.json at ${paths.furnaceConfig}: ${toError(error).message}`);
-    }
-}
-/**
- * Clears applied furnace state while preserving `pendingRepair`.
- *
- * Used whenever the engine baseline is replaced or reset (download --force,
- * reset, rebase, rebase --abort): every applied checksum describes content
- * that no longer exists, but pendingRepair tracks authoring-side rollback
- * issues in the component WORKSPACE and must survive an engine refresh.
- * No-ops when the state file does not exist.
- */
-export async function clearAppliedFurnaceState(root) {
-    const paths = getFurnacePaths(root);
-    if (!(await pathExists(paths.furnaceState)))
-        return;
-    await updateFurnaceState(root, (current) => ({
-        ...(current.pendingRepair ? { pendingRepair: current.pendingRepair } : {}),
-    }));
-}
-/**
- * Writes a furnace configuration to furnace.json.
- * @param root - Root directory of the project
- * @param config - Configuration to write
- */
-export async function writeFurnaceConfig(root, config) {
-    const paths = getFurnacePaths(root);
-    let existing;
-    if (await pathExists(paths.furnaceConfig)) {
-        try {
-            const raw = await readJson(paths.furnaceConfig);
-            // JSON.parse only produces JSON data, so the object check is the
-            // only invariant left for the JsonObject contract.
-            if (isObject(raw))
-                existing = raw;
-        }
-        catch {
-            // A missing or corrupt furnace.json means there is no prior document to
-            // preserve key order from. The writer falls back to canonical ordering.
-            existing = undefined;
-        }
-    }
-    await writeJson(paths.furnaceConfig, orderFurnaceConfigForWrite(existing, config));
-}
-/**
- * Stamps every override's `baseVersion` to the supplied version. Used by
- * `fireforge rebase` after a successful patch re-export, so an ESR bump does
- * not leave Furnace overrides in a doctor-failing drift state: `rebase`
- * stamps patch `sourceEsrVersion` via `stampPatchVersions`, and without the
- * matching override stamp `doctor` fails Furnace component validation on
- * every override.
- *
- * The stamp is unconditional: `fireforge furnace validate` is the right
- * tool for "does this override still apply", and rebase has
- * already attested that the patch layer re-validated against the new ESR.
- *
- * @param root - Root directory of the project
- * @param version - Firefox version string to stamp onto every override
- * @returns Number of overrides whose `baseVersion` was updated (either
- *   because it was missing or because it differed from `version`).
- */
-export async function stampFurnaceOverrideBaseVersions(root, version) {
-    if (!(await furnaceConfigExists(root)))
-        return 0;
-    const config = await loadFurnaceConfig(root);
-    let changed = 0;
-    for (const override of Object.values(config.overrides)) {
-        if (override.baseVersion !== version) {
-            override.baseVersion = version;
-            changed++;
-        }
-    }
-    if (changed > 0) {
-        await writeFurnaceConfig(root, config);
-    }
-    return changed;
-}
-/**
- * Creates a default furnace configuration.
- *
- * When a `binaryName` is provided, the default config carries a
- * `tokenPrefix` derived as `--<binaryName>-`. Without it, `fireforge token
- * coverage` on a fresh project reports `0 tokens` and labels every
- * custom-property reference as `unknown`, because the scan has no prefix to
- * key off. Deriving the prefix from the binary name matches the convention
- * the scaffolded tokens CSS already uses for its `--<binaryName>-*`
- * declarations.
- *
- * `validateFurnaceConfig` treats `tokenPrefix` as optional, so callers on
- * the no-arg call shape still get a valid config without a prefix. The CLI
- * init path always has a `binaryName` from `fireforge.json` and always sets
- * one.
- *
- * @param options - Optional init context. Pass `{ binaryName }` to derive
- *   the token prefix.
- * @returns A valid FurnaceConfig
- */
-export function createDefaultFurnaceConfig(options = {}) {
-    const config = {
-        version: 1,
-        componentPrefix: 'moz-',
-        stock: [],
-        overrides: {},
-        custom: {},
-    };
-    if (options.binaryName && options.binaryName.length > 0) {
-        config.tokenPrefix = `--${options.binaryName}-`;
-    }
-    return config;
-}
-/**
- * Loads furnace config if it exists, or creates and writes a default config.
- * @param root - Root directory of the project
- * @returns FurnaceConfig (existing or newly created)
- */
-export async function ensureFurnaceConfig(root) {
-    if (await furnaceConfigExists(root)) {
-        return loadFurnaceConfig(root);
-    }
-    const config = createDefaultFurnaceConfig();
-    await writeFurnaceConfig(root, config);
-    return config;
-}
-/**
- * Loads the furnace state, or returns defaults if it doesn't exist.
- * @param root - Root directory of the project
- * @returns Furnace state
- */
-export async function loadFurnaceState(root) {
-    const paths = getFurnacePaths(root);
-    return loadFurnaceStateFromPath(paths.furnaceState);
-}
-/**
- * Saves the furnace state.
- * @param root - Root directory of the project
- * @param state - State to save
- */
-export async function saveFurnaceState(root, state) {
-    const paths = getFurnacePaths(root);
-    const validatedState = validateFurnaceState(state);
-    await withStateFileLock(paths.furnaceState, async () => {
-        await writeJson(paths.furnaceState, validatedState);
-    });
-}
-/**
- * Updates furnace state fields transactionally under the state file lock.
- * @param root - Root directory of the project
- * @param updates - Fields to update, or a transactional updater function
- */
-export async function updateFurnaceState(root, updates) {
-    const paths = getFurnacePaths(root);
-    await withStateFileLock(paths.furnaceState, async () => {
-        const current = await loadFurnaceStateFromPath(paths.furnaceState, true);
-        const nextState = typeof updates === 'function' ? updates(current) : { ...current, ...updates };
-        await writeJson(paths.furnaceState, validateFurnaceState(nextState));
-    });
-}
-/**
- * Engine-relative path of the directory `furnace preview` writes its
- * generated Storybook story files into. Treated as Furnace-managed so
- * `status` does not flag them as unmanaged and `lint` does not fail on their
- * (intentionally bare) license headers. They are tool output rather than
- * files an operator commits or hand-edits.
- */
-const FURNACE_STORYBOOK_STORIES_PREFIX = 'browser/components/storybook/stories/furnace/';
-/**
- * Collects engine-relative path prefixes that are managed by the Furnace
- * component system (overrides, custom components, and their Fluent l10n
- * files). Used by `status` and `export-all` to classify engine changes
- * as Furnace-managed rather than unmanaged drift.
- *
- * Returns an empty set when no furnace config exists (opt-in subsystem).
- * Prefixes always end with `/` so callers can use `startsWith()`.
- */
-export async function collectFurnaceManagedPrefixes(root) {
-    if (!(await furnaceConfigExists(root)))
-        return new Set();
-    const config = await loadFurnaceConfig(root);
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    const prefixes = new Set();
-    for (const [, overrideCfg] of Object.entries(config.overrides)) {
-        const base = overrideCfg.basePath.endsWith('/')
-            ? overrideCfg.basePath
-            : overrideCfg.basePath + '/';
-        prefixes.add(base);
-    }
-    for (const [, customCfg] of Object.entries(config.custom)) {
-        const target = customCfg.targetPath.endsWith('/')
-            ? customCfg.targetPath
-            : customCfg.targetPath + '/';
-        prefixes.add(target);
-        if (customCfg.localized) {
-            prefixes.add(ftlDir.endsWith('/') ? ftlDir : ftlDir + '/');
-        }
-    }
-    // Always include the preview-generated stories prefix when furnace is
-    // initialised. The directory may not exist yet (no preview ever ran),
-    // but classifying it as furnace-managed is safe even when empty. Status
-    // simply has nothing to bucket.
-    prefixes.add(FURNACE_STORYBOOK_STORIES_PREFIX);
-    return prefixes;
-}

package/dist/src/core/furnace-constants.d.ts

@@ -1,81 +0,0 @@
-/** Path to customElements.js within the engine source tree */
-export declare const CUSTOM_ELEMENTS_JS = "toolkit/content/customElements.js";
-/** Path to jar.mn within the engine source tree (toolkit global) */
-export declare const JAR_MN = "toolkit/content/jar.mn";
-/**
- * Upstream home of the MozLitElement widget sources.
- *
- * The trailing slash is not included: `build-audit-transforms.ts` needs
- * `${WIDGETS_DIR}/` and its ordered prefix table depends on that slash, so
- * appending it at the one site that wants it keeps the others correct.
- */
-export declare const WIDGETS_DIR = "toolkit/content/widgets";
-/** Chrome URL prefix under which a component's `.mjs` files deploy. */
-export declare const CHROME_ELEMENTS_URL_PREFIX = "chrome://global/content/elements/";
-/** Default Fluent localization directory for toolkit global components, relative to engine root */
-export declare const FTL_DIR = "toolkit/locales/en-US/toolkit/global";
-/**
- * Engine-relative root every browser-chrome / xpcshell test scaffold lives
- * under, trailing slash included. A `--test-dir` override must stay below
- * it so the `browser/base/moz.build` manifest registration keeps working.
- */
-export declare const BROWSER_TEST_SCAFFOLD_ROOT = "browser/base/content/test/";
-/**
- * Returns the engine-relative directory that holds xpcshell scaffolds for
- * a given binary. Matches the form `create-xpcshell.ts` writes and the
- * path `remove.ts` / `rename.ts` / `validate.ts` must clean up.
- */
-export declare function xpcshellTestParentDir(binaryName: string): string;
-/**
- * Resolves the engine-relative directory a browser-chrome scaffold is
- * written to: the `--test-dir` override when given, else
- * `browser/base/content/test/<binaryName>`. The scaffolder and the
- * dry-run / success formatters resolve through this one function, so the
- * printed plan cannot disagree with the files that land on disk.
- */
-export declare function resolveBrowserChromeTestDir(binaryName: string, override?: string): string;
-/**
- * Resolves the engine-relative directory an xpcshell scaffold is written
- * to. A `--test-dir` override names the final directory (no per-component
- * segment is appended). The default is
- * `browser/base/content/test/<binaryName>-xpcshell/<componentName>`.
- */
-export declare function resolveXpcshellTestDir(binaryName: string, componentName: string, override?: string): string;
-/** Returns true when `fileName` has one of the standard component file extensions. */
-export declare function isComponentSourceFile(fileName: string): boolean;
-/**
- * Resolves the FTL base path, preferring the user-configured value from
- * `furnace.json` over the built-in default.
- */
-export declare function resolveFtlDir(configuredPath?: string): string;
-/**
- * Resolves the chrome sub-path that `document.l10n` / `insertFTLIfNeeded`
- * expects for a given `ftlBasePath`. Strips the mandatory `locales/<LOCALE>/`
- * segment. For the default `toolkit/locales/en-US/toolkit/global` this yields
- * `toolkit/global`.
- *
- * Returns `undefined` when no `locales/<LOCALE>/` segment is present. Callers
- * must treat that as "cannot confidently locate the locale jar.mn entry" and
- * degrade gracefully rather than inventing a path.
- */
-export declare function resolveFtlChromeSubPath(ftlBasePath?: string): string | undefined;
-/**
- * Returns the engine-relative locale jar.mn that owns the FTL tree for a
- * given `ftlBasePath`. For the default toolkit tree this yields
- * `toolkit/locales/jar.mn`.
- *
- * Returns `undefined` when the path does not contain a `locales/` segment.
- * Callers must treat that as "cannot locate" and degrade gracefully.
- */
-export declare function resolveFtlLocaleJarMnPath(ftlBasePath?: string): string | undefined;
-/**
- * Converts a kebab-case tag name to PascalCase class name.
- * e.g. "moz-sidebar-panel" → "MozSidebarPanel"
- */
-export declare function tagNameToClassName(tagName: string): string;
-/**
- * Strips a known component prefix from a tag name to produce a concise
- * display name. Falls back to the full tag name when the prefix doesn't
- * match, so callers never receive an empty string.
- */
-export declare function stripComponentPrefix(tagName: string, componentPrefix: string): string;