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

package/dist/esm-node/oxlint-plugin.js

@@ -0,0 +1,317 @@
+import "node:module";
+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 oxlint_plugin_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 oxlint_plugin = oxlint_plugin_plugin;
+export default oxlint_plugin;

package/dist/types/cli/i18n-check.d.ts

@@ -0,0 +1,9 @@
+type SingleAppI18nCheckOptions = {
+    readonly cwd?: string;
+    readonly targets?: readonly string[];
+};
+export declare const SINGLE_APP_I18N_SUCCESS = "No hardcoded user-visible JSX strings found.";
+export declare const SINGLE_APP_I18N_FAILURE = "Hardcoded user-visible JSX strings found. Move copy to locale JSON files.";
+export declare const runSingleAppI18nCheck: ({ cwd, targets, }?: SingleAppI18nCheckOptions) => number;
+export declare const main: () => void;
+export {};

package/dist/types/cli/oxlint.d.ts

@@ -0,0 +1,22 @@
+type OxlintRuleConfig = string | readonly [
+    string,
+    {
+        readonly [key: string]: unknown;
+    }
+];
+type OxlintRules = {
+    readonly [ruleName: string]: OxlintRuleConfig;
+};
+type OxlintRulesOptions = {
+    readonly cwd: string;
+    readonly targets: readonly string[];
+    readonly rules: OxlintRules;
+};
+type OxlintRulesResult = {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export declare const runOxlintRules: ({ cwd, targets, rules, }: OxlintRulesOptions) => OxlintRulesResult;
+export declare const printOxlintOutput: ({ stdout, stderr, }: OxlintRulesResult) => void;
+export {};

package/dist/types/cli/workspace-source-check.d.ts

@@ -0,0 +1,8 @@
+type WorkspaceSourceCheckOptions = {
+    readonly cwd?: string;
+    readonly sourceRoots?: readonly string[];
+};
+export declare const WORKSPACE_SOURCE_SUCCESS = "UltraModern i18n and boundary guardrails validated";
+export declare const runWorkspaceSourceCheck: ({ cwd, sourceRoots, }?: WorkspaceSourceCheckOptions) => number;
+export declare const main: () => void;
+export {};

package/dist/types/index.d.ts

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

package/dist/types/oxlint-plugin.d.ts

@@ -0,0 +1,63 @@
+type AstNode = {
+    readonly type?: string;
+    readonly parent?: AstNode;
+    readonly loc?: {
+        readonly start?: {
+            readonly line?: number;
+        };
+        readonly end?: {
+            readonly line?: number;
+        };
+    };
+    readonly value?: unknown;
+    readonly raw?: unknown;
+    readonly name?: unknown;
+    readonly openingElement?: AstNode;
+    readonly expression?: AstNode;
+    readonly expressions?: readonly AstNode[];
+    readonly quasis?: readonly AstNode[];
+    readonly test?: AstNode;
+    readonly consequent?: AstNode;
+    readonly alternate?: AstNode;
+    readonly arguments?: readonly AstNode[];
+    readonly callee?: AstNode;
+    readonly object?: AstNode;
+    readonly property?: AstNode;
+    readonly computed?: boolean;
+};
+type RuleContext = {
+    readonly options?: readonly unknown[];
+    readonly filename?: string;
+    getSourceCode?: () => {
+        readonly text?: string;
+        getAllComments?: () => readonly AstNode[];
+        getText?: (node: AstNode) => string;
+    };
+    report: (descriptor: {
+        readonly node: AstNode;
+        readonly message: string;
+    }) => void;
+};
+type Rule = {
+    readonly meta: {
+        readonly type: string;
+        readonly docs: {
+            readonly description: string;
+        };
+        readonly schema: unknown[];
+    };
+    create(context: RuleContext): Record<string, (node: AstNode) => void>;
+};
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-hardcoded-jsx-text': Rule;
+        'no-legacy-mf-boundary-attributes': Rule;
+        'no-literal-visible-jsx-attributes': Rule;
+        'no-manual-locale-copy-branching': Rule;
+        'no-split-translation-keys': Rule;
+    };
+};
+export default plugin;

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@bleedingdev/modern-js-code-tools",
+  "description": "Code analysis tooling for Modern.js projects.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/toolkit/code-tools"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js",
+    "lint",
+    "oxlint"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "version": "3.2.0-ultramodern.111",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/esm-node/index.js",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ],
+      "oxlint-plugin": [
+        "./dist/types/oxlint-plugin.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.js",
+        "require": "./dist/cjs/index.cjs"
+      },
+      "default": "./dist/esm-node/index.js"
+    },
+    "./oxlint-plugin": {
+      "types": "./dist/types/oxlint-plugin.d.ts",
+      "node": {
+        "import": "./dist/esm-node/oxlint-plugin.js",
+        "require": "./dist/cjs/oxlint-plugin.cjs"
+      },
+      "default": "./dist/esm-node/oxlint-plugin.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "oxlint": "1.68.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/node": "^25.9.1",
+    "@typescript/native-preview": "7.0.0-dev.20260606.1",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "modern:source": "./src/index.ts",
+  "scripts": {
+    "build": "rm -rf dist && rslib build -c rslib.config.mts && pnpm -w tsgo:dts \"$PWD\"",
+    "dev": "rslib build -c rslib.config.mts -w",
+    "test": "rstest --passWithNoTests"
+  }
+}