@bleedingdev/modern-js-code-tools 3.2.0-ultramodern.111

package/dist/cjs/oxlint-plugin.cjs

@@ -0,0 +1,354 @@
+"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 commonOptionsSchema = {
+    type: 'object',
+    properties: {
+        allowElements: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        ignoreCommentPattern: {
+            type: 'string'
+        }
+    },
+    additionalProperties: false
+};
+const attributeOptionsSchema = {
+    type: 'object',
+    properties: {
+        ...commonOptionsSchema.properties,
+        visibleAttributes: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    },
+    additionalProperties: false
+};
+const translationOptionsSchema = {
+    type: 'object',
+    properties: {
+        translationFunctions: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    },
+    additionalProperties: false
+};
+const DEFAULT_VISIBLE_ATTRIBUTES = [
+    'aria-label',
+    "aria-description",
+    "aria-roledescription",
+    'aria-valuetext',
+    'alt',
+    'placeholder',
+    'title'
+];
+const DEFAULT_ALLOWED_ELEMENTS = [
+    'code',
+    'kbd',
+    'samp'
+];
+const DEFAULT_TRANSLATION_FUNCTIONS = [
+    't'
+];
+const DEFAULT_IGNORE_COMMENT_PATTERN = 'i18n-ignore';
+const LETTER_PATTERN = /\p{L}/u;
+const SPLIT_TRANSLATION_KEY_PATTERN = /\.(?:prefix|suffix|before|after)$/u;
+const isRecord = (value)=>Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+const asStringArray = (value, fallback)=>Array.isArray(value) && value.every((item)=>'string' == typeof item) ? value : fallback;
+const getCommonRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    if (!isRecord(options)) return defaults;
+    return {
+        allowElements: asStringArray(options.allowElements, defaults.allowElements),
+        ignoreCommentPattern: 'string' == typeof options.ignoreCommentPattern ? options.ignoreCommentPattern : defaults.ignoreCommentPattern
+    };
+};
+const getAttributeRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    const commonOptions = getCommonRuleOption(context, defaults);
+    return {
+        ...commonOptions,
+        visibleAttributes: isRecord(options) ? asStringArray(options.visibleAttributes, defaults.visibleAttributes) : defaults.visibleAttributes
+    };
+};
+const getSplitTranslationKeyRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    if (!isRecord(options)) return defaults;
+    return {
+        translationFunctions: asStringArray(options.translationFunctions, defaults.translationFunctions)
+    };
+};
+const normalizeVisibleText = (value)=>value.replaceAll(/\s+/gu, ' ').trim();
+const hasLetters = (value)=>LETTER_PATTERN.test(value);
+const getNodeName = (node)=>{
+    if (!node) return;
+    if ('string' == typeof node.name) return node.name;
+    if ('JSXIdentifier' === node.type && isRecord(node.name) && 'string' == typeof node.name.name) return node.name.name;
+    if ('JSXIdentifier' === node.type && 'string' == typeof node.name) return node.name;
+    if (('JSXMemberExpression' === node.type || 'MemberExpression' === node.type) && isRecord(node.property) && true !== node.computed) {
+        const objectName = getNodeName(node.object);
+        const propertyName = getNodeName(node.property);
+        return objectName && propertyName ? `${objectName}.${propertyName}` : propertyName;
+    }
+};
+const getJsxElementName = (node)=>{
+    if (node?.type !== 'JSXElement') return;
+    return getNodeName(node.openingElement?.name);
+};
+const hasAllowedElementAncestor = (node, allowedElements)=>{
+    let current = node;
+    while(current){
+        const elementName = getJsxElementName(current);
+        if (elementName && allowedElements.has(elementName)) return true;
+        current = current.parent;
+    }
+    return false;
+};
+const getTemplateLiteralValue = (node)=>{
+    if ('TemplateLiteral' !== node.type || (node.expressions?.length ?? 0) > 0) return;
+    const quasi = node.quasis?.[0];
+    if (!isRecord(quasi?.value)) return;
+    const cooked = quasi.value.cooked;
+    const raw = quasi.value.raw;
+    return 'string' == typeof cooked ? cooked : 'string' == typeof raw ? raw : void 0;
+};
+const getStringLiteralValue = (node)=>{
+    if (!node) return;
+    if (('Literal' === node.type || 'StringLiteral' === node.type) && 'string' == typeof node.value) return node.value;
+    return getTemplateLiteralValue(node);
+};
+const expressionStringValue = (node)=>getStringLiteralValue(node?.type === 'JSXExpressionContainer' ? node.expression : node);
+const getLine = (node)=>node.loc?.start?.line;
+const hasIgnoreComment = (node, context, pattern)=>{
+    const sourceCode = context.getSourceCode?.();
+    const nodeLine = getLine(node);
+    if (!sourceCode?.getAllComments || void 0 === nodeLine) return false;
+    return sourceCode.getAllComments().some((comment)=>{
+        const commentValue = String(comment.value ?? '');
+        if (!pattern.test(commentValue)) return false;
+        const startLine = comment.loc?.start?.line;
+        const endLine = comment.loc?.end?.line ?? startLine;
+        return void 0 !== startLine && void 0 !== endLine && startLine <= nodeLine + 1 && endLine >= nodeLine - 1;
+    });
+};
+const getIgnorePattern = (options)=>new RegExp(options.ignoreCommentPattern, 'u');
+const reportVisibleText = (context, node, text)=>{
+    context.report({
+        node,
+        message: `Move user-visible JSX text to locale resources: ${JSON.stringify(text)}`
+    });
+};
+const createNoHardcodedJsxTextRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow literal user-visible text in JSX children in UltraModern generated apps.'
+            },
+            schema: [
+                commonOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = getCommonRuleOption(context, {
+                allowElements: DEFAULT_ALLOWED_ELEMENTS,
+                ignoreCommentPattern: DEFAULT_IGNORE_COMMENT_PATTERN
+            });
+            const allowedElements = new Set(options.allowElements);
+            const ignorePattern = getIgnorePattern(options);
+            const shouldSkipNode = (node)=>hasAllowedElementAncestor(node, allowedElements) || hasIgnoreComment(node, context, ignorePattern);
+            return {
+                JSXText (node) {
+                    const text = normalizeVisibleText(String(node.value ?? ''));
+                    if (!text || !hasLetters(text) || shouldSkipNode(node)) return;
+                    reportVisibleText(context, node, text);
+                },
+                JSXExpressionContainer (node) {
+                    if (node.parent?.type !== 'JSXElement' && node.parent?.type !== 'JSXFragment') return;
+                    const text = normalizeVisibleText(expressionStringValue(node.expression) ?? '');
+                    if (!text || !hasLetters(text) || shouldSkipNode(node)) return;
+                    reportVisibleText(context, node, text);
+                }
+            };
+        }
+    });
+const createNoLiteralVisibleJsxAttributesRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow literal user-visible JSX attribute text in UltraModern generated apps.'
+            },
+            schema: [
+                attributeOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = getAttributeRuleOption(context, {
+                allowElements: DEFAULT_ALLOWED_ELEMENTS,
+                ignoreCommentPattern: DEFAULT_IGNORE_COMMENT_PATTERN,
+                visibleAttributes: DEFAULT_VISIBLE_ATTRIBUTES
+            });
+            const visibleAttributes = new Set(options.visibleAttributes);
+            const ignorePattern = getIgnorePattern(options);
+            return {
+                JSXAttribute (node) {
+                    const attributeName = getNodeName(node.name);
+                    if (!attributeName || !visibleAttributes.has(attributeName)) return;
+                    const text = normalizeVisibleText(expressionStringValue(node.value) ?? '');
+                    if (!text || !hasLetters(text) || hasIgnoreComment(node, context, ignorePattern)) return;
+                    context.report({
+                        node,
+                        message: `Move literal ${attributeName} copy to locale resources: ${JSON.stringify(text)}`
+                    });
+                }
+            };
+        }
+    });
+const getSourceText = (context, node)=>context.getSourceCode?.().getText?.(node) ?? '';
+const looksLikeLocaleTest = (context, node)=>{
+    const text = getSourceText(context, node);
+    return /\b(?:language|locale|lng|currentLanguage)\b/u.test(text) && /(?:={2,3}|!==?)/u.test(text) && /['"][a-z]{2}(?:-[A-Za-z0-9]+)?['"]/u.test(text);
+};
+const isAllowedBranchLiteral = (text)=>new Set([
+        'page',
+        'undefined',
+        'null',
+        'true',
+        'false'
+    ]).has(text);
+const createNoManualLocaleCopyBranchingRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow manual locale conditionals that choose user-visible copy.'
+            },
+            schema: []
+        },
+        create (context) {
+            const reportBranch = (node, text)=>{
+                context.report({
+                    node,
+                    message: `Move locale-specific copy branch to i18n resources: ${JSON.stringify(normalizeVisibleText(text))}`
+                });
+            };
+            return {
+                ConditionalExpression (node) {
+                    if (!node.test || !looksLikeLocaleTest(context, node.test)) return;
+                    for (const branch of [
+                        node.consequent,
+                        node.alternate
+                    ]){
+                        const text = expressionStringValue(branch);
+                        if (text && hasLetters(text) && !isAllowedBranchLiteral(text.trim())) reportBranch(branch, text);
+                    }
+                }
+            };
+        }
+    });
+const getCallExpressionName = (node)=>getNodeName(node);
+const createNoSplitTranslationKeysRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow split phrase translation key suffixes such as .prefix and .suffix.'
+            },
+            schema: [
+                translationOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = getSplitTranslationKeyRuleOption(context, {
+                translationFunctions: DEFAULT_TRANSLATION_FUNCTIONS
+            });
+            const translationFunctions = new Set(options.translationFunctions);
+            return {
+                CallExpression (node) {
+                    const calleeName = getCallExpressionName(node.callee);
+                    if (!calleeName || !translationFunctions.has(calleeName)) return;
+                    const key = expressionStringValue(node.arguments?.[0]);
+                    if (!key || !SPLIT_TRANSLATION_KEY_PATTERN.test(key)) return;
+                    context.report({
+                        node,
+                        message: 'Keep translator-owned phrases whole instead of using split translation keys.'
+                    });
+                }
+            };
+        }
+    });
+const createNoLegacyMfBoundaryAttributesRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow legacy Module Federation boundary attributes in generated UltraModern workspaces.'
+            },
+            schema: []
+        },
+        create (context) {
+            return {
+                JSXAttribute (node) {
+                    const attributeName = getNodeName(node.name);
+                    if ('data-mf-boundary' !== attributeName && 'data-mf-remote' !== attributeName && 'data-mf-expose' !== attributeName) return;
+                    context.report({
+                        node,
+                        message: 'Use data-modern-boundary-id and data-modern-mf-expose instead of legacy data-mf-* boundary attributes.'
+                    });
+                }
+            };
+        }
+    });
+const plugin = {
+    meta: {
+        name: 'ultramodern'
+    },
+    rules: {
+        'no-hardcoded-jsx-text': createNoHardcodedJsxTextRule(),
+        'no-legacy-mf-boundary-attributes': createNoLegacyMfBoundaryAttributesRule(),
+        'no-literal-visible-jsx-attributes': createNoLiteralVisibleJsxAttributesRule(),
+        'no-manual-locale-copy-branching': createNoManualLocaleCopyBranchingRule(),
+        'no-split-translation-keys': createNoSplitTranslationKeysRule()
+    }
+};
+const __rspack_default_export = plugin;
+__webpack_require__.d(__webpack_exports__, {}, {
+    default: __rspack_default_export
+});
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/i18n-check.js

@@ -0,0 +1,26 @@
+import { printOxlintOutput, runOxlintRules } from "./oxlint.js";
+const SINGLE_APP_I18N_SUCCESS = 'No hardcoded user-visible JSX strings found.';
+const SINGLE_APP_I18N_FAILURE = 'Hardcoded user-visible JSX strings found. Move copy to locale JSON files.';
+const runSingleAppI18nCheck = ({ cwd = process.cwd(), targets = [
+    'src'
+] } = {})=>{
+    const result = runOxlintRules({
+        cwd,
+        targets,
+        rules: {
+            'ultramodern/no-hardcoded-jsx-text': 'error',
+            'ultramodern/no-literal-visible-jsx-attributes': 'error'
+        }
+    });
+    if (0 === result.exitCode) {
+        console.log(SINGLE_APP_I18N_SUCCESS);
+        return 0;
+    }
+    console.error(SINGLE_APP_I18N_FAILURE);
+    printOxlintOutput(result);
+    return result.exitCode;
+};
+const main = ()=>{
+    process.exitCode = runSingleAppI18nCheck();
+};
+export { SINGLE_APP_I18N_FAILURE, SINGLE_APP_I18N_SUCCESS, main, runSingleAppI18nCheck };

package/dist/esm/cli/oxlint.js

@@ -0,0 +1,118 @@
+import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_os from "node:os";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const oxlint_require = createRequire(import.meta.url);
+const ignoredDirectories = new Set([
+    '.modern',
+    '.modernjs',
+    '.output',
+    'dist',
+    'node_modules'
+]);
+const packageNames = new Set([
+    '@modern-js/code-tools',
+    '@bleedingdev/modern-js-code-tools'
+]);
+const resolveExistingPath = (candidates)=>candidates.find((candidate)=>node_fs.existsSync(candidate));
+const findPackageRoot = ()=>{
+    let directory = node_path.dirname(fileURLToPath(import.meta.url));
+    while(directory !== node_path.dirname(directory)){
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        if (node_fs.existsSync(packageJsonPath)) try {
+            const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+            if (packageNames.has(packageJson.name)) return directory;
+        } catch  {
+            return directory;
+        }
+        directory = node_path.dirname(directory);
+    }
+    throw new Error('Unable to resolve @modern-js/code-tools package root.');
+};
+const resolvePluginPath = ()=>{
+    const root = findPackageRoot();
+    const sourcePluginPath = node_path.join(root, 'src/oxlint-plugin.ts');
+    const pluginPath = resolveExistingPath([
+        node_path.join(root, 'dist/esm-node/oxlint-plugin.mjs'),
+        node_path.join(root, 'dist/esm-node/oxlint-plugin.js'),
+        node_path.join(root, 'dist/esm/oxlint-plugin.mjs'),
+        node_path.join(root, 'dist/esm/oxlint-plugin.js'),
+        node_path.join(root, 'dist/cjs/oxlint-plugin.js'),
+        node_path.join(root, 'dist/cjs/oxlint-plugin.cjs'),
+        sourcePluginPath
+    ]);
+    if (!pluginPath) throw new Error('Unable to resolve @modern-js/code-tools Oxlint plugin.');
+    return pluginPath;
+};
+const resolveOxlintBin = ()=>{
+    const packageJsonPath = oxlint_require.resolve('oxlint/package.json');
+    const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+    const binRelativePath = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.oxlint;
+    if (!binRelativePath) throw new Error('Unable to resolve oxlint binary.');
+    return node_path.join(node_path.dirname(packageJsonPath), binRelativePath);
+};
+const existingTargets = (cwd, targets)=>targets.map((target)=>node_path.resolve(cwd, target)).filter((target)=>node_fs.existsSync(target));
+const containsLintableSource = (filePath)=>{
+    if (!node_fs.existsSync(filePath)) return false;
+    const stats = node_fs.statSync(filePath);
+    if (stats.isFile()) return /\.(?:js|jsx|ts|tsx)$/u.test(filePath) && !filePath.endsWith('.d.ts');
+    if (!stats.isDirectory()) return false;
+    for (const entry of node_fs.readdirSync(filePath, {
+        withFileTypes: true
+    }))if (!(entry.isDirectory() && ignoredDirectories.has(entry.name))) {
+        if (containsLintableSource(node_path.join(filePath, entry.name))) return true;
+    }
+    return false;
+};
+const runOxlintRules = ({ cwd, targets, rules })=>{
+    const resolvedTargets = existingTargets(cwd, targets);
+    if (0 === resolvedTargets.length || !resolvedTargets.some((target)=>containsLintableSource(target))) return {
+        exitCode: 0,
+        stdout: '',
+        stderr: ''
+    };
+    const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-oxlint-'));
+    const configPath = node_path.join(tempDir, 'oxlint.config.mjs');
+    const pluginPath = resolvePluginPath();
+    node_fs.writeFileSync(configPath, `export default {
+  jsPlugins: [${JSON.stringify(pluginPath)}],
+  rules: ${JSON.stringify(rules, null, 2)}
+};
+`, 'utf-8');
+    try {
+        const result = spawnSync(process.execPath, [
+            resolveOxlintBin(),
+            ...resolvedTargets,
+            '--config',
+            configPath,
+            '--format',
+            'unix',
+            '--quiet'
+        ], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        return {
+            exitCode: result.status ?? 1,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? ''
+        };
+    } finally{
+        node_fs.rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    }
+};
+const printOxlintOutput = ({ stdout, stderr })=>{
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+};
+export { printOxlintOutput, runOxlintRules };

package/dist/esm/cli/workspace-source-check.js

@@ -0,0 +1,124 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { printOxlintOutput, runOxlintRules } from "./oxlint.js";
+const WORKSPACE_SOURCE_SUCCESS = 'UltraModern i18n and boundary guardrails validated';
+const ignoredDirectories = new Set([
+    '.modern',
+    '.modernjs',
+    '.output',
+    'dist',
+    'node_modules'
+]);
+const normalizePath = (filePath)=>filePath.replaceAll('\\', '/');
+const relativePath = (root, filePath)=>normalizePath(node_path.relative(root, filePath));
+const walk = (directory, files = [])=>{
+    if (!node_fs.existsSync(directory)) return files;
+    for (const entry of node_fs.readdirSync(directory, {
+        withFileTypes: true
+    })){
+        if (entry.isDirectory() && ignoredDirectories.has(entry.name)) continue;
+        const entryPath = node_path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walk(entryPath, files);
+            continue;
+        }
+        if (entry.isFile()) files.push(entryPath);
+    }
+    return files;
+};
+const isSourceFile = (filePath)=>/\.(?:ts|tsx|js|jsx)$/u.test(filePath);
+const isLocaleJson = (root, filePath)=>/\/locales\/(?:en|cs)\/[^/]+\.json$/u.test(`/${relativePath(root, filePath)}`);
+const readText = (filePath)=>node_fs.readFileSync(filePath, 'utf-8');
+const checkRuntimeResources = (root, filePath, text)=>{
+    const relative = relativePath(root, filePath);
+    if (!relative.endsWith('/src/modern.runtime.ts')) return;
+    const importsLocaleResources = /import\s+csResource\s+from\s+['"]\.\.\/locales\/cs\/[^'"]+\.json['"]/u.test(text) && /import\s+enResource\s+from\s+['"]\.\.\/locales\/en\/[^'"]+\.json['"]/u.test(text);
+    if (!importsLocaleResources || !/initOptions\s*:\s*\{[\s\S]*?\bresources\s*,/u.test(text)) throw new Error(`${relative} must register locale JSON resources in modern.runtime.ts so Worker SSR and hydration use the same first-render translations.`);
+};
+const visitLocaleKeys = (value, visitor, pathParts = [])=>{
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    for (const [key, child] of Object.entries(value)){
+        const nextPath = [
+            ...pathParts,
+            key
+        ];
+        visitor(key, child, nextPath);
+        visitLocaleKeys(child, visitor, nextPath);
+    }
+};
+const checkPluralResources = (root, filePath, json)=>{
+    const relative = relativePath(root, filePath);
+    const language = relative.split('/locales/')[1]?.split('/')[0];
+    const requiredSuffixes = 'cs' === language ? [
+        'one',
+        'few',
+        'many',
+        'other'
+    ] : [
+        'one',
+        'other'
+    ];
+    const groups = new Map();
+    visitLocaleKeys(json, (key, value, pathParts)=>{
+        if ('string' != typeof value || !value.includes('{{count}}')) return;
+        const suffixMatch = key.match(/^(.*)_(one|few|many|other)$/u);
+        if (!suffixMatch) throw new Error(`${relative} key ${pathParts.join('.')} contains {{count}} but is not plural-suffixed.`);
+        const [, base = '', suffix = ''] = suffixMatch;
+        const parentPath = pathParts.slice(0, -1).join('.');
+        const groupKey = `${parentPath}.${base}`;
+        const existing = groups.get(groupKey) ?? new Set();
+        existing.add(suffix);
+        groups.set(groupKey, existing);
+    });
+    for (const [group, suffixes] of groups)for (const suffix of requiredSuffixes)if (!suffixes.has(suffix)) throw new Error(`${relative} plural group ${group} is missing _${suffix}.`);
+};
+const runRuntimeAndLocaleResourceChecks = (root, sourceRoots)=>{
+    const files = sourceRoots.flatMap((sourceRoot)=>walk(node_path.join(root, sourceRoot)));
+    for (const filePath of files.filter(isSourceFile))checkRuntimeResources(root, filePath, readText(filePath));
+    for (const filePath of files.filter((filePath)=>isLocaleJson(root, filePath)))checkPluralResources(root, filePath, JSON.parse(readText(filePath)));
+};
+const runWorkspaceSourceCheck = ({ cwd = process.cwd(), sourceRoots = [
+    'apps',
+    'verticals'
+] } = {})=>{
+    const oxlintResult = runOxlintRules({
+        cwd,
+        targets: sourceRoots,
+        rules: {
+            'ultramodern/no-legacy-mf-boundary-attributes': 'error',
+            'ultramodern/no-literal-visible-jsx-attributes': [
+                'error',
+                {
+                    visibleAttributes: [
+                        'aria-label',
+                        "aria-description",
+                        "aria-roledescription",
+                        'aria-valuetext',
+                        'alt',
+                        'label',
+                        'placeholder',
+                        'title'
+                    ]
+                }
+            ],
+            'ultramodern/no-manual-locale-copy-branching': 'error',
+            'ultramodern/no-split-translation-keys': 'error'
+        }
+    });
+    if (0 !== oxlintResult.exitCode) {
+        printOxlintOutput(oxlintResult);
+        return oxlintResult.exitCode;
+    }
+    try {
+        runRuntimeAndLocaleResourceChecks(cwd, sourceRoots);
+    } catch (error) {
+        console.error(error instanceof Error ? error.message : 'UltraModern workspace source checks failed.');
+        return 1;
+    }
+    console.log(WORKSPACE_SOURCE_SUCCESS);
+    return 0;
+};
+const main = ()=>{
+    process.exitCode = runWorkspaceSourceCheck();
+};
+export { WORKSPACE_SOURCE_SUCCESS, main, runWorkspaceSourceCheck };

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { runSingleAppI18nCheck } from "./cli/i18n-check.js";
+export { runWorkspaceSourceCheck } from "./cli/workspace-source-check.js";
+export { default as oxlintPlugin } from "./oxlint-plugin.js";