@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/config-validate-patch-policy.js

@@ -1,274 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Validation helpers for `fireforge.json#patchPolicy`.
- */
-import { ConfigError } from '../errors/config.js';
-import { toError } from '../utils/errors.js';
-import { parseObject } from '../utils/parse.js';
-import { isContainedRelativePath } from '../utils/paths.js';
-const PATCH_POLICY_MUTATION_MODES = ['error', 'warn', 'force'];
-function optionalConfigString(rec, key, label) {
-    const value = rec.raw(key);
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'string') {
-        throw new ConfigError(`Config field "${label}" must be a string`);
-    }
-    return value;
-}
-function parsePositiveRangeEndpoint(raw, label) {
-    if (typeof raw !== 'number' || !Number.isInteger(raw) || raw <= 0) {
-        throw new ConfigError(`Config field "${label}" must be a positive integer`);
-    }
-    return raw;
-}
-function parsePatchPolicyCategory(raw, label) {
-    if (typeof raw !== 'string' || !/^[a-z][a-z0-9-]*$/.test(raw)) {
-        throw new ConfigError(`Config field "${label}" must be a lowercase category identifier (letters, numbers, hyphens)`);
-    }
-    return raw;
-}
-/**
- * Shared head of every patch-policy range shape: the value must be an
- * object carrying positive integer `from`/`to` endpoints with
- * `to >= from`. Returns the parsed record so callers can read their
- * shape-specific fields from it.
- */
-function parseRangeBounds(raw, label) {
-    let rec;
-    try {
-        rec = parseObject(raw, label);
-    }
-    catch {
-        throw new ConfigError(`Config field "${label}" must be an object`);
-    }
-    const from = parsePositiveRangeEndpoint(rec.raw('from'), `${label}.from`);
-    const to = parsePositiveRangeEndpoint(rec.raw('to'), `${label}.to`);
-    if (to < from) {
-        throw new ConfigError(`Config field "${label}.to" must be greater than or equal to from`);
-    }
-    return { rec, from, to };
-}
-function parsePatchPolicyRange(raw, label) {
-    const { rec, from, to } = parseRangeBounds(raw, label);
-    return {
-        from,
-        to,
-        category: parsePatchPolicyCategory(rec.raw('category'), `${label}.category`),
-    };
-}
-function parsePatchPolicyDocumentPath(raw, label) {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== 'string' || raw.trim() === '') {
-        throw new ConfigError(`Config field "${label}" must be a non-empty string`);
-    }
-    if (!isContainedRelativePath(raw)) {
-        throw new ConfigError(`Config field "${label}" must be a project-relative path`);
-    }
-    return raw;
-}
-function parseReservedAllowedPatch(raw, label) {
-    let rec;
-    try {
-        rec = parseObject(raw, label);
-    }
-    catch {
-        throw new ConfigError(`Config field "${label}" must be an object`);
-    }
-    const filename = optionalConfigString(rec, 'filename', `${label}.filename`);
-    if (filename === undefined || filename.trim() === '') {
-        throw new ConfigError(`Config field "${label}.filename" must be a non-empty string`);
-    }
-    const files = rec.raw('files');
-    let parsedFiles;
-    if (files !== undefined) {
-        if (!Array.isArray(files) || files.some((value) => typeof value !== 'string')) {
-            throw new ConfigError(`Config field "${label}.files" must be an array of strings`);
-        }
-        parsedFiles = files;
-    }
-    const adr = parsePatchPolicyDocumentPath(rec.raw('adr'), `${label}.adr`);
-    const documentation = parsePatchPolicyDocumentPath(rec.raw('documentation'), `${label}.documentation`);
-    const out = { filename };
-    if (parsedFiles !== undefined)
-        out.files = parsedFiles;
-    if (adr !== undefined)
-        out.adr = adr;
-    if (documentation !== undefined)
-        out.documentation = documentation;
-    return out;
-}
-function parsePatchPolicyReservedRange(raw, label) {
-    const { rec, from, to } = parseRangeBounds(raw, label);
-    const allowedRaw = rec.raw('allowed');
-    if (!Array.isArray(allowedRaw)) {
-        throw new ConfigError(`Config field "${label}.allowed" must be an array`);
-    }
-    return {
-        from,
-        to,
-        allowed: allowedRaw.map((entry, index) => parseReservedAllowedPatch(entry, `${label}.allowed[${index}]`)),
-    };
-}
-function assertPolicyRangesDoNotOverlap(ranges, label) {
-    const sorted = [...ranges].sort((a, b) => a.from - b.from || a.to - b.to);
-    for (let i = 1; i < sorted.length; i++) {
-        const previous = sorted[i - 1];
-        const current = sorted[i];
-        if (previous && current && current.from <= previous.to) {
-            throw new ConfigError(`Config field "${label}" must not contain overlapping ranges (${previous.from}-${previous.to} overlaps ${current.from}-${current.to})`);
-        }
-    }
-}
-function parseNonEmptyString(raw, label) {
-    if (typeof raw !== 'string' || raw.trim() === '') {
-        throw new ConfigError(`Config field "${label}" must be a non-empty string`);
-    }
-    return raw;
-}
-function parseGlobList(raw, label) {
-    if (!Array.isArray(raw) || raw.length === 0) {
-        throw new ConfigError(`Config field "${label}" must be a non-empty array of path globs`);
-    }
-    return raw.map((entry, index) => parseNonEmptyString(entry, `${label}[${index}]`));
-}
-function parseUpstreamAllowEntry(raw, label, defaultMarker) {
-    if (typeof raw === 'string')
-        return parseNonEmptyString(raw, label);
-    let rec;
-    try {
-        rec = parseObject(raw, label);
-    }
-    catch {
-        throw new ConfigError(`Config field "${label}" must be a path glob or an object`);
-    }
-    const entry = {
-        path: parseNonEmptyString(rec.raw('path'), `${label}.path`),
-    };
-    const addOnly = rec.raw('addOnly');
-    if (addOnly !== undefined) {
-        if (typeof addOnly !== 'boolean') {
-            throw new ConfigError(`Config field "${label}.addOnly" must be a boolean`);
-        }
-        entry.addOnly = addOnly;
-    }
-    const marker = rec.raw('marker');
-    if (marker !== undefined)
-        entry.marker = parseNonEmptyString(marker, `${label}.marker`);
-    if (entry.addOnly === true && entry.marker === undefined && defaultMarker === undefined) {
-        throw new ConfigError(`Config field "${label}" sets addOnly but no marker: set "${label}.marker" or "patchPolicy.addOnlyMarker"`);
-    }
-    return entry;
-}
-function parseScopeRule(raw, label) {
-    let rec;
-    try {
-        rec = parseObject(raw, label);
-    }
-    catch {
-        throw new ConfigError(`Config field "${label}" must be an object`);
-    }
-    const rule = { files: parseGlobList(rec.raw('files'), `${label}.files`) };
-    const category = rec.raw('category');
-    if (category !== undefined) {
-        rule.category = parsePatchPolicyCategory(category, `${label}.category`);
-    }
-    const filenamePattern = optionalConfigString(rec, 'filenamePattern', `${label}.filenamePattern`);
-    if (filenamePattern !== undefined) {
-        try {
-            new RegExp(filenamePattern);
-        }
-        catch (error) {
-            throw new ConfigError(`Config field "${label}.filenamePattern" must be a valid regular expression: ${toError(error).message}`);
-        }
-        rule.filenamePattern = filenamePattern;
-    }
-    if (rule.category === undefined && rule.filenamePattern === undefined) {
-        throw new ConfigError(`Config field "${label}" must set "category" or "filenamePattern" to select the patches it scopes`);
-    }
-    return rule;
-}
-/**
- * Parses the registration-only policy fields: `upstreamAllowlist`,
- * `addOnlyMarker`, `scopeRules` and `verifyDocumentPaths`. All opt-in.
- */
-function parsePatchPolicyContentRules(rec, out) {
-    const addOnlyMarker = rec.raw('addOnlyMarker');
-    if (addOnlyMarker !== undefined) {
-        out.addOnlyMarker = parseNonEmptyString(addOnlyMarker, 'patchPolicy.addOnlyMarker');
-    }
-    const allowlist = rec.raw('upstreamAllowlist');
-    if (allowlist !== undefined) {
-        if (!Array.isArray(allowlist)) {
-            throw new ConfigError('Config field "patchPolicy.upstreamAllowlist" must be an array');
-        }
-        out.upstreamAllowlist = allowlist.map((entry, index) => parseUpstreamAllowEntry(entry, `patchPolicy.upstreamAllowlist[${index}]`, out.addOnlyMarker));
-    }
-    const scopeRules = rec.raw('scopeRules');
-    if (scopeRules !== undefined) {
-        if (!Array.isArray(scopeRules)) {
-            throw new ConfigError('Config field "patchPolicy.scopeRules" must be an array');
-        }
-        out.scopeRules = scopeRules.map((entry, index) => parseScopeRule(entry, `patchPolicy.scopeRules[${index}]`));
-    }
-    const verifyDocumentPaths = rec.raw('verifyDocumentPaths');
-    if (verifyDocumentPaths !== undefined) {
-        if (typeof verifyDocumentPaths !== 'boolean') {
-            throw new ConfigError('Config field "patchPolicy.verifyDocumentPaths" must be a boolean');
-        }
-        out.verifyDocumentPaths = verifyDocumentPaths;
-    }
-}
-/** Parses and validates the optional patch policy config block. */
-export function parsePatchPolicyBlock(rec) {
-    const out = { ranges: [] };
-    const filenamePattern = optionalConfigString(rec, 'filenamePattern', 'patchPolicy.filenamePattern');
-    if (filenamePattern !== undefined) {
-        try {
-            new RegExp(filenamePattern);
-        }
-        catch (error) {
-            throw new ConfigError(`Config field "patchPolicy.filenamePattern" must be a valid regular expression: ${toError(error).message}`);
-        }
-        out.filenamePattern = filenamePattern;
-    }
-    const requireDescription = rec.raw('requireDescription');
-    if (requireDescription !== undefined) {
-        if (typeof requireDescription !== 'boolean') {
-            throw new ConfigError('Config field "patchPolicy.requireDescription" must be a boolean');
-        }
-        out.requireDescription = requireDescription;
-    }
-    const allowGaps = rec.raw('allowGaps');
-    if (allowGaps !== undefined) {
-        if (typeof allowGaps !== 'boolean') {
-            throw new ConfigError('Config field "patchPolicy.allowGaps" must be a boolean');
-        }
-        out.allowGaps = allowGaps;
-    }
-    const mutationMode = rec.raw('mutationMode');
-    if (mutationMode !== undefined) {
-        if (typeof mutationMode !== 'string' ||
-            !PATCH_POLICY_MUTATION_MODES.includes(mutationMode)) {
-            throw new ConfigError(`Config field "patchPolicy.mutationMode" must be one of: ${PATCH_POLICY_MUTATION_MODES.join(', ')}`);
-        }
-        out.mutationMode = mutationMode;
-    }
-    const rangesRaw = rec.raw('ranges');
-    if (!Array.isArray(rangesRaw) || rangesRaw.length === 0) {
-        throw new ConfigError('Config field "patchPolicy.ranges" must be a non-empty array');
-    }
-    out.ranges = rangesRaw.map((entry, index) => parsePatchPolicyRange(entry, `patchPolicy.ranges[${index}]`));
-    assertPolicyRangesDoNotOverlap(out.ranges, 'patchPolicy.ranges');
-    const reservedRangesRaw = rec.raw('reservedRanges');
-    if (reservedRangesRaw !== undefined) {
-        if (!Array.isArray(reservedRangesRaw)) {
-            throw new ConfigError('Config field "patchPolicy.reservedRanges" must be an array');
-        }
-        out.reservedRanges = reservedRangesRaw.map((entry, index) => parsePatchPolicyReservedRange(entry, `patchPolicy.reservedRanges[${index}]`));
-        assertPolicyRangesDoNotOverlap(out.reservedRanges, 'patchPolicy.reservedRanges');
-    }
-    parsePatchPolicyContentRules(rec, out);
-    return out;
-}

package/dist/src/core/config-validate-test-toolchains.d.ts

@@ -1,8 +0,0 @@
-import type { FireForgeConfig } from '../types/config.js';
-import type { ParsedRecord } from '../utils/parse.js';
-type ConfigRecord = ParsedRecord;
-/** Parses the optional `test` block. */
-export declare function parseTestBlock(rec: ConfigRecord, config: FireForgeConfig): void;
-/** Parses optional project-specific external toolchain doctor probes. */
-export declare function parseExternalToolchainsBlock(rec: ConfigRecord, config: FireForgeConfig): void;
-export {};

package/dist/src/core/config-validate-test-toolchains.js

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { ConfigError } from '../errors/config.js';
-import { isContainedRelativePath } from '../utils/paths.js';
-import { isObject } from '../utils/validation.js';
-function optionalConfigString(rec, key, label) {
-    const value = rec.raw(key);
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'string') {
-        throw new ConfigError(`Config field "${label}" must be a string`);
-    }
-    return value;
-}
-function optionalConfigObject(rec, key) {
-    const value = rec.raw(key);
-    if (value === undefined)
-        return undefined;
-    try {
-        return rec.object(key);
-    }
-    catch {
-        throw new ConfigError(`Config field "${key}" must be an object`);
-    }
-}
-/** Parses the optional `test` block. */
-export function parseTestBlock(rec, config) {
-    const testRec = optionalConfigObject(rec, 'test');
-    if (!testRec)
-        return;
-    const out = {};
-    const canaryPath = optionalConfigString(testRec, 'canaryPath', 'test.canaryPath');
-    if (canaryPath !== undefined) {
-        if (canaryPath.trim() === '' || !isContainedRelativePath(canaryPath)) {
-            throw new ConfigError('Config field "test.canaryPath" must be a project-relative path');
-        }
-        out.canaryPath = canaryPath;
-    }
-    const canaryTimeout = testRec.raw('canaryTimeoutSeconds');
-    if (canaryTimeout !== undefined) {
-        if (typeof canaryTimeout !== 'number' ||
-            !Number.isInteger(canaryTimeout) ||
-            canaryTimeout < 1 ||
-            canaryTimeout > 600) {
-            throw new ConfigError('Config field "test.canaryTimeoutSeconds" must be an integer in 1..600');
-        }
-        out.canaryTimeoutSeconds = canaryTimeout;
-    }
-    const reapOrphans = testRec.raw('reapOrphans');
-    if (reapOrphans !== undefined) {
-        if (reapOrphans !== 'report' && reapOrphans !== 'reap') {
-            throw new ConfigError('Config field "test.reapOrphans" must be "report" or "reap"');
-        }
-        out.reapOrphans = reapOrphans;
-    }
-    const mochitestPorts = testRec.raw('mochitestPorts');
-    if (mochitestPorts !== undefined) {
-        if (mochitestPorts !== 'fixed' && mochitestPorts !== 'auto') {
-            throw new ConfigError('Config field "test.mochitestPorts" must be "fixed" or "auto"');
-        }
-        out.mochitestPorts = mochitestPorts;
-    }
-    const lockMode = testRec.raw('lockMode');
-    if (lockMode !== undefined) {
-        if (lockMode !== 'exclusive' && lockMode !== 'shared') {
-            throw new ConfigError('Config field "test.lockMode" must be "exclusive" or "shared"');
-        }
-        out.lockMode = lockMode;
-    }
-    const furnaceApply = testRec.raw('furnaceApply');
-    if (furnaceApply !== undefined) {
-        if (furnaceApply !== 'all' && furnaceApply !== 'reached' && furnaceApply !== 'none') {
-            throw new ConfigError('Config field "test.furnaceApply" must be "all", "reached" or "none"');
-        }
-        out.furnaceApply = furnaceApply;
-    }
-    config.test = out;
-}
-/** Parses optional project-specific external toolchain doctor probes. */
-export function parseExternalToolchainsBlock(rec, config) {
-    const raw = rec.raw('externalToolchains');
-    if (raw === undefined)
-        return;
-    if (!Array.isArray(raw)) {
-        throw new ConfigError('Config field "externalToolchains" must be an array');
-    }
-    config.externalToolchains = raw.map((entry, index) => {
-        if (!isObject(entry)) {
-            throw new ConfigError(`Config field "externalToolchains[${index}]" must be an object`);
-        }
-        const item = entry;
-        const name = item['name'];
-        if (typeof name !== 'string' || name.trim() === '') {
-            throw new ConfigError(`Config field "externalToolchains[${index}].name" must be a non-empty string`);
-        }
-        const tools = item['tools'];
-        if (!Array.isArray(tools) || tools.length === 0) {
-            throw new ConfigError(`Config field "externalToolchains[${index}].tools" must be a non-empty array`);
-        }
-        return {
-            name,
-            tools: tools.map((tool, toolIndex) => parseExternalToolRequirement(tool, index, toolIndex)),
-        };
-    });
-}
-function parseExternalToolRequirement(tool, index, toolIndex) {
-    const label = `externalToolchains[${index}].tools[${toolIndex}]`;
-    if (!isObject(tool)) {
-        throw new ConfigError(`Config field "${label}" must be an object`);
-    }
-    const toolRec = tool;
-    const toolName = toolRec['name'];
-    if (typeof toolName !== 'string' || toolName.trim() === '') {
-        throw new ConfigError(`Config field "${label}.name" must be a non-empty string`);
-    }
-    const toolPath = toolRec['path'];
-    if (toolPath !== undefined && (typeof toolPath !== 'string' || toolPath.trim() === '')) {
-        throw new ConfigError(`Config field "${label}.path" must be a non-empty string`);
-    }
-    const xcrun = toolRec['xcrun'];
-    if (xcrun !== undefined && typeof xcrun !== 'boolean') {
-        throw new ConfigError(`Config field "${label}.xcrun" must be a boolean`);
-    }
-    const required = toolRec['required'];
-    if (required !== undefined && typeof required !== 'boolean') {
-        throw new ConfigError(`Config field "${label}.required" must be a boolean`);
-    }
-    return {
-        name: toolName,
-        ...(toolPath !== undefined ? { path: toolPath } : {}),
-        ...(xcrun !== undefined ? { xcrun } : {}),
-        ...(required !== undefined ? { required } : {}),
-    };
-}

package/dist/src/core/config-validate-token-scales.d.ts

@@ -1,9 +0,0 @@
-/**
- * Validation for `fireforge.json#patchLint.tokenScales`.
- *
- * Unknown keys are refused: a misspelt `allowInCalc` or `minFiles` would
- * otherwise loosen or drop a scale without a word.
- */
-import type { PatchLintTokenScale } from '../types/config.js';
-/** Parses and validates `patchLint.tokenScales`. */
-export declare function parsePatchLintTokenScales(raw: unknown): PatchLintTokenScale[];

package/dist/src/core/config-validate-token-scales.js

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Validation for `fireforge.json#patchLint.tokenScales`.
- *
- * Unknown keys are refused: a misspelt `allowInCalc` or `minFiles` would
- * otherwise loosen or drop a scale without a word.
- */
-import { ConfigError } from '../errors/config.js';
-import { parseObject } from '../utils/parse.js';
-const SCALE_KEYS = [
-    'properties',
-    'prefix',
-    'allowLiterals',
-    'allow',
-    'allowInCalc',
-    'offsetCap',
-    'exclude',
-    'minFiles',
-];
-const PREFIX_PATTERN = /^--[\w-]+$/;
-function parseNames(raw, label, required) {
-    if (raw === undefined && !required)
-        return undefined;
-    if (!Array.isArray(raw) ||
-        (required && raw.length === 0) ||
-        raw.some((value) => typeof value !== 'string' || value.trim() === '')) {
-        throw new ConfigError(`Config field "${label}" must be ${required ? 'a non-empty' : 'an'} array of non-empty strings`);
-    }
-    return raw;
-}
-function parsePrefix(raw, label) {
-    const prefixes = Array.isArray(raw) ? raw : [raw];
-    if (prefixes.length === 0 ||
-        prefixes.some((prefix) => typeof prefix !== 'string' || !PREFIX_PATTERN.test(prefix))) {
-        throw new ConfigError(`Config field "${label}.prefix" must be a custom-property prefix such as "--mybrowser-space-", or a non-empty list of them`);
-    }
-    return Array.isArray(raw) ? prefixes : raw;
-}
-function parseNumber(raw, label, integer) {
-    const valid = typeof raw === 'number' && Number.isFinite(raw) && (integer ? Number.isInteger(raw) : true);
-    if (!valid || raw < (integer ? 1 : 0)) {
-        throw new ConfigError(`Config field "${label}" must be ${integer ? 'a positive integer' : 'a non-negative number'}`);
-    }
-    return raw;
-}
-function parseTokenScale(raw, label) {
-    let rec;
-    try {
-        rec = parseObject(raw, label);
-    }
-    catch {
-        throw new ConfigError(`Config field "${label}" must be an object`);
-    }
-    for (const key of Object.keys(raw)) {
-        if (!SCALE_KEYS.includes(key)) {
-            throw new ConfigError(`Config field "${label}" has unknown key "${key}"`);
-        }
-    }
-    const properties = parseNames(rec.raw('properties'), `${label}.properties`, true) ?? [];
-    const scale = { properties, prefix: parsePrefix(rec.raw('prefix'), label) };
-    const allowLiterals = parseNames(rec.raw('allowLiterals'), `${label}.allowLiterals`, false);
-    if (allowLiterals !== undefined)
-        scale.allowLiterals = allowLiterals;
-    const allow = parseNames(rec.raw('allow'), `${label}.allow`, false);
-    if (allow !== undefined) {
-        const malformed = allow.find((name) => !name.startsWith('--'));
-        if (malformed !== undefined) {
-            throw new ConfigError(`Config field "${label}.allow" entries must be custom-property names starting with "--" (got "${malformed}")`);
-        }
-        scale.allow = allow;
-    }
-    const allowInCalc = parseNames(rec.raw('allowInCalc'), `${label}.allowInCalc`, false);
-    if (allowInCalc !== undefined)
-        scale.allowInCalc = allowInCalc;
-    const offsetCap = rec.raw('offsetCap');
-    if (offsetCap !== undefined)
-        scale.offsetCap = parseNumber(offsetCap, `${label}.offsetCap`, false);
-    const exclude = parseNames(rec.raw('exclude'), `${label}.exclude`, false);
-    if (exclude !== undefined)
-        scale.exclude = exclude;
-    const minFiles = rec.raw('minFiles');
-    if (minFiles !== undefined)
-        scale.minFiles = parseNumber(minFiles, `${label}.minFiles`, true);
-    return scale;
-}
-/** Parses and validates `patchLint.tokenScales`. */
-export function parsePatchLintTokenScales(raw) {
-    if (!Array.isArray(raw)) {
-        throw new ConfigError('Config field "patchLint.tokenScales" must be an array');
-    }
-    return raw.map((entry, index) => parseTokenScale(entry, `patchLint.tokenScales[${index}]`));
-}

package/dist/src/core/config-validate.d.ts

@@ -1,11 +0,0 @@
-/**
- * Config schema validation for fireforge.json.
- */
-import type { FireForgeConfig } from '../types/config.js';
-/**
- * Validates a raw config object and returns a typed FireForgeConfig.
- * @param data - Raw data to validate
- * @returns Validated FireForgeConfig
- * @throws Error if validation fails
- */
-export declare function validateConfig(data: unknown): FireForgeConfig;