@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/cjs/ultramodern/designSystem.js

@@ -1,123 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-const DESIGN_SYSTEM_MODES = [
-    'off',
-    'tokens',
-    'components',
-    'strict'
-];
-const DESIGN_SYSTEM_OVERRIDE_LAYERS = [
-    'brand',
-    'vertical',
-    'application'
-];
-const VALID_MODES = new Set(DESIGN_SYSTEM_MODES);
-const VALID_OVERRIDE_LAYERS = new Set(DESIGN_SYSTEM_OVERRIDE_LAYERS);
-const createValidationResult = (issues)=>({
-        valid: 0 === issues.length,
-        issues
-    });
-const addIssue = (issues, path, message)=>{
-    issues.push({
-        path,
-        message
-    });
-};
-const createDesignSystemTokenPackMap = (tokenPacks)=>new Map(tokenPacks.map((tokenPack)=>[
-            tokenPack.id,
-            tokenPack
-        ]));
-const validateDesignSystemConsumerCompatibility = (vertical, tokenPack, path = 'vertical')=>{
-    const issues = [];
-    const consumers = vertical.consumers ?? [];
-    for (const [consumerIndex, consumer] of consumers.entries()){
-        const consumerPath = `${path}.consumers[${consumerIndex}]`;
-        if (consumer.unsupportedModes?.includes(vertical.mode)) addIssue(issues, `${consumerPath}.unsupportedModes`, `consumer "${consumer.id}" does not support "${vertical.mode}" mode`);
-        if (!tokenPack) continue;
-        const expectedVersion = consumer.tokenPackVersions?.[tokenPack.id];
-        if (expectedVersion && expectedVersion !== tokenPack.version) addIssue(issues, `${consumerPath}.tokenPackVersions.${tokenPack.id}`, `consumer "${consumer.id}" requires "${tokenPack.id}" version "${expectedVersion}" but received "${tokenPack.version}"`);
-        for (const tokenName of consumer.requiredTokens ?? [])if (!(tokenName in tokenPack.tokens)) addIssue(issues, `${consumerPath}.requiredTokens`, `consumer "${consumer.id}" requires missing token "${tokenName}" from "${tokenPack.id}"`);
-    }
-    return createValidationResult(issues);
-};
-const validateDesignSystemContract = (contract)=>{
-    const issues = [];
-    const tokenPackMap = createDesignSystemTokenPackMap(contract.tokenPacks);
-    for (const [tokenPackIndex, tokenPack] of contract.tokenPacks.entries()){
-        const tokenPackPath = `tokenPacks[${tokenPackIndex}]`;
-        if (tokenPackMap.get(tokenPack.id) !== tokenPack) addIssue(issues, `${tokenPackPath}.id`, `duplicate token pack id "${tokenPack.id}"`);
-        if (0 === Object.keys(tokenPack.tokens).length) addIssue(issues, `${tokenPackPath}.tokens`, `token pack "${tokenPack.id}" must define at least one token`);
-    }
-    for (const [verticalName, vertical] of Object.entries(contract.verticals)){
-        const verticalPath = `verticals.${verticalName}`;
-        const tokenPack = vertical.tokenPack ? tokenPackMap.get(vertical.tokenPack) : void 0;
-        if (!VALID_MODES.has(vertical.mode)) addIssue(issues, `${verticalPath}.mode`, `unsupported design system mode "${vertical.mode}"`);
-        if ('off' !== vertical.mode && !vertical.tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `vertical "${verticalName}" must select a token pack when mode is "${vertical.mode}"`);
-        if (vertical.tokenPack && !tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `unknown token pack "${vertical.tokenPack}"`);
-        for (const [overrideIndex, override] of (vertical.overrides ?? []).entries())if (!VALID_OVERRIDE_LAYERS.has(override.layer)) addIssue(issues, `${verticalPath}.overrides[${overrideIndex}].layer`, `override layer "${override.layer}" is not approved`);
-        if (vertical.pin) {
-            const pinnedTokenPack = tokenPackMap.get(vertical.pin.tokenPack);
-            const rollbackTokenPack = tokenPackMap.get(vertical.pin.rollback.tokenPack);
-            if (pinnedTokenPack) {
-                if (pinnedTokenPack.version !== vertical.pin.version) addIssue(issues, `${verticalPath}.pin.version`, `pinned version "${vertical.pin.version}" does not match token pack "${vertical.pin.tokenPack}" version "${pinnedTokenPack.version}"`);
-            } else addIssue(issues, `${verticalPath}.pin.tokenPack`, `unknown pinned token pack "${vertical.pin.tokenPack}"`);
-            if (vertical.tokenPack && vertical.pin.tokenPack !== vertical.tokenPack) addIssue(issues, `${verticalPath}.pin.tokenPack`, `pinned token pack "${vertical.pin.tokenPack}" must match selected token pack "${vertical.tokenPack}"`);
-            if (rollbackTokenPack) {
-                if (rollbackTokenPack.version !== vertical.pin.rollback.version) addIssue(issues, `${verticalPath}.pin.rollback.version`, `rollback version "${vertical.pin.rollback.version}" does not match token pack "${vertical.pin.rollback.tokenPack}" version "${rollbackTokenPack.version}"`);
-            } else addIssue(issues, `${verticalPath}.pin.rollback.tokenPack`, `unknown rollback token pack "${vertical.pin.rollback.tokenPack}"`);
-            if (!vertical.pin.rollback.reason) addIssue(issues, `${verticalPath}.pin.rollback.reason`, 'rollback metadata must include a reason');
-        }
-        const compatibility = validateDesignSystemConsumerCompatibility(vertical, tokenPack, verticalPath);
-        issues.push(...compatibility.issues);
-    }
-    return createValidationResult(issues);
-};
-__webpack_require__.d(__webpack_exports__, {}, {
-    DESIGN_SYSTEM_MODES: DESIGN_SYSTEM_MODES,
-    DESIGN_SYSTEM_OVERRIDE_LAYERS: DESIGN_SYSTEM_OVERRIDE_LAYERS,
-    createDesignSystemTokenPackMap: createDesignSystemTokenPackMap,
-    validateDesignSystemConsumerCompatibility: validateDesignSystemConsumerCompatibility,
-    validateDesignSystemContract: validateDesignSystemContract
-});
-exports.DESIGN_SYSTEM_MODES = __webpack_exports__.DESIGN_SYSTEM_MODES;
-exports.DESIGN_SYSTEM_OVERRIDE_LAYERS = __webpack_exports__.DESIGN_SYSTEM_OVERRIDE_LAYERS;
-exports.createDesignSystemTokenPackMap = __webpack_exports__.createDesignSystemTokenPackMap;
-exports.validateDesignSystemConsumerCompatibility = __webpack_exports__.validateDesignSystemConsumerCompatibility;
-exports.validateDesignSystemContract = __webpack_exports__.validateDesignSystemContract;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "DESIGN_SYSTEM_MODES",
-    "DESIGN_SYSTEM_OVERRIDE_LAYERS",
-    "createDesignSystemTokenPackMap",
-    "validateDesignSystemConsumerCompatibility",
-    "validateDesignSystemContract"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/baseline.mjs

@@ -1,4 +0,0 @@
-import { createPresetUltramodernConfig, presetUltramodern } from "./presetUltramodern.mjs";
-const createAppBaselineConfig = createPresetUltramodernConfig;
-const withAppBaseline = presetUltramodern;
-export { createAppBaselineConfig, withAppBaseline };

package/dist/esm/commands/runtime.mjs

@@ -1,146 +0,0 @@
-const DEFAULT_RUNTIME_HOST = 'http://127.0.0.1:8080';
-const DEFAULT_RUNTIME_STATUS_PATH = '/_modern/runtime/status';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_PATH = '/_modern/contract-gates/runtime-fallback';
-const DEFAULT_RUNTIME_TOKEN_HEADER = 'x-modernjs-runtime-signal-token';
-const DEFAULT_TIMEOUT_MS = 5000;
-const resolveRuntimeEndpoint = (input, defaultPath)=>{
-    const rawInput = input?.trim();
-    if (!rawInput) return `${DEFAULT_RUNTIME_HOST}${defaultPath}`;
-    if (rawInput.startsWith('http://') || rawInput.startsWith('https://')) return rawInput;
-    const normalized = rawInput.startsWith('/') ? rawInput : `/${rawInput}`;
-    return `${DEFAULT_RUNTIME_HOST}${normalized}`;
-};
-const resolveToken = ({ token, tokenEnv })=>{
-    if ('string' == typeof token && token.trim().length > 0) return token.trim();
-    if ('string' == typeof tokenEnv && tokenEnv.trim().length > 0) {
-        const value = process.env[tokenEnv.trim()];
-        if ('string' == typeof value && value.trim().length > 0) return value.trim();
-    }
-};
-const parseTimeoutMs = (value)=>{
-    if ('string' != typeof value || 0 === value.trim().length) return DEFAULT_TIMEOUT_MS;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_TIMEOUT_MS;
-    return parsed;
-};
-const parseMetadata = (metadata)=>{
-    if ('string' != typeof metadata || 0 === metadata.trim().length) return;
-    const parsed = JSON.parse(metadata);
-    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new Error('metadata must be a JSON object');
-    return parsed;
-};
-const fetchWithTimeout = async (url, init, timeoutMs)=>{
-    const controller = new AbortController();
-    const timeout = setTimeout(()=>{
-        controller.abort();
-    }, timeoutMs);
-    try {
-        return await fetch(url, {
-            ...init,
-            signal: controller.signal
-        });
-    } finally{
-        clearTimeout(timeout);
-    }
-};
-const parseResponseBody = async (response)=>{
-    const text = await response.text();
-    if (!text) return {};
-    try {
-        return JSON.parse(text);
-    } catch (_error) {
-        return {
-            raw: text
-        };
-    }
-};
-const INDENT_STEP = '  ';
-const formatScalar = (value)=>'string' == typeof value ? value : JSON.stringify(value) ?? 'undefined';
-const formatHumanReadableLines = (value, indent)=>{
-    if (Array.isArray(value)) {
-        if (0 === value.length) return [
-            `${indent}(empty)`
-        ];
-        return value.flatMap((entry)=>null !== entry && 'object' == typeof entry ? [
-                `${indent}-`,
-                ...formatHumanReadableLines(entry, indent + INDENT_STEP)
-            ] : [
-                `${indent}- ${formatScalar(entry)}`
-            ]);
-    }
-    if (null !== value && 'object' == typeof value) {
-        const entries = Object.entries(value);
-        if (0 === entries.length) return [
-            `${indent}(empty)`
-        ];
-        return entries.flatMap(([key, entry])=>null !== entry && 'object' == typeof entry ? [
-                `${indent}${key}:`,
-                ...formatHumanReadableLines(entry, indent + INDENT_STEP)
-            ] : [
-                `${indent}${key}: ${formatScalar(entry)}`
-            ]);
-    }
-    return [
-        `${indent}${formatScalar(value)}`
-    ];
-};
-const formatRuntimeOutput = (payload, jsonOnly)=>jsonOnly ? JSON.stringify(payload, null, 2) : formatHumanReadableLines(payload, '').join('\n');
-const printOutput = (payload, jsonOnly)=>{
-    console.log(formatRuntimeOutput(payload, jsonOnly));
-};
-const createRuntimeFallbackSignalPayload = (options)=>{
-    const payload = {
-        appName: options.app,
-        reason: options.reason || 'runtime_fallback',
-        phase: options.phase || 'load'
-    };
-    if (options.entry) payload.entry = options.entry;
-    if (options.runtimeDigest) payload.runtimeDigest = options.runtimeDigest;
-    const metadata = parseMetadata(options.metadata);
-    if (metadata) payload.metadata = metadata;
-    return payload;
-};
-const runtimeCommand = async (program, _api)=>{
-    const runtime = program.command('runtime').description('runtime operations');
-    runtime.command('status').description('read runtime status snapshot').option('--endpoint <endpoint>', 'runtime status endpoint URL or path').option('--token <token>', 'runtime status auth token').option('--token-env <name>', 'environment variable name that stores runtime status auth token', 'MODERN_RUNTIME_SIGNAL_TOKEN').option('--header-name <name>', 'auth header name', DEFAULT_RUNTIME_TOKEN_HEADER).option('--timeout <ms>', 'request timeout in milliseconds', '5000').option('--json', 'output as JSON format for machine reading').action(async (options)=>{
-        const endpoint = resolveRuntimeEndpoint(options.endpoint, DEFAULT_RUNTIME_STATUS_PATH);
-        const timeoutMs = parseTimeoutMs(options.timeout);
-        const token = resolveToken({
-            token: options.token,
-            tokenEnv: options.tokenEnv
-        });
-        const headerName = options.headerName?.trim() || DEFAULT_RUNTIME_TOKEN_HEADER;
-        const headers = new Headers();
-        if (token) headers.set(headerName, token);
-        const response = await fetchWithTimeout(endpoint, {
-            method: 'GET',
-            headers
-        }, timeoutMs);
-        const payload = await parseResponseBody(response);
-        if (!response.ok) throw new Error(`runtime status request failed with ${response.status}: ${JSON.stringify(payload)}`);
-        printOutput(payload, options.json);
-    });
-    runtime.command('fallback-signal').description('emit runtime fallback signal for canary gate mutation').requiredOption('--app <appName>', 'remote app name').option('--endpoint <endpoint>', 'runtime fallback signal endpoint URL or path').option('--reason <reason>', 'fallback reason', 'runtime_fallback').option('--phase <phase>', 'fallback phase', 'load').option('--entry <entry>', 'remote entry URL').option('--runtime-digest <digest>', 'runtime digest value').option('--metadata <json>', 'metadata JSON object string').option('--token <token>', 'runtime signal auth token').option('--token-env <name>', 'environment variable name that stores runtime signal auth token', 'MODERN_RUNTIME_SIGNAL_TOKEN').option('--header-name <name>', 'auth header name', DEFAULT_RUNTIME_TOKEN_HEADER).option('--timeout <ms>', 'request timeout in milliseconds', '5000').option('--json', 'output as JSON format for machine reading').action(async (options)=>{
-        const endpoint = resolveRuntimeEndpoint(options.endpoint, DEFAULT_RUNTIME_FALLBACK_SIGNAL_PATH);
-        const timeoutMs = parseTimeoutMs(options.timeout);
-        const token = resolveToken({
-            token: options.token,
-            tokenEnv: options.tokenEnv
-        });
-        const headerName = options.headerName?.trim() || DEFAULT_RUNTIME_TOKEN_HEADER;
-        const payload = createRuntimeFallbackSignalPayload(options);
-        const headers = new Headers({
-            'content-type': 'application/json'
-        });
-        if (token) headers.set(headerName, token);
-        const response = await fetchWithTimeout(endpoint, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(payload)
-        }, timeoutMs);
-        const responsePayload = await parseResponseBody(response);
-        if (!response.ok) throw new Error(`runtime fallback signal request failed with ${response.status}: ${JSON.stringify(responsePayload)}`);
-        printOutput(responsePayload, options.json);
-    });
-};
-export { createRuntimeFallbackSignalPayload, formatRuntimeOutput, resolveRuntimeEndpoint, resolveToken, runtimeCommand };