@ashstack/lint 0.1.0

package/dist/core/rules/core/no-naming-convention.js

@@ -0,0 +1,143 @@
+import { problem } from "../../../lib/ast.js";
+const IDENTIFIER_NAME = /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u;
+const CAMEL_CASE = /^[a-z][A-Za-z0-9]*$/;
+const PASCAL_CASE = /^[A-Z][A-Za-z0-9]*$/;
+const CONSTANT_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
+const SNAKE_CASE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+const PLACEHOLDER_NAME = /^_+$/;
+const FORMAT_TESTS = {
+    camelCase: name => CAMEL_CASE.test(name),
+    PascalCase: name => PASCAL_CASE.test(name) && /[a-z]/.test(name),
+    CONSTANT_CASE: name => CONSTANT_CASE.test(name),
+    snake_case: name => SNAKE_CASE.test(name),
+};
+const ANY_CASE = ["camelCase", "snake_case", "CONSTANT_CASE", "PascalCase"];
+const LEGEND_STATE_OBSERVABLE_SUFFIX = String.raw `\$?`;
+const AFFIXED_NAME = String.raw `[$_]*([A-Za-z](?:[A-Za-z0-9_]*[A-Za-z0-9])?)_*${LEGEND_STATE_OBSERVABLE_SUFFIX}`;
+const NUMERIC_KEY = String.raw `(?:[0-9.]+)`;
+const LIBRARY_PROPERTY_NAMES = [
+    "enableFullScreenImage_legacy",
+    "experimental_backgroundImage",
+    "unstable_conditionNames",
+];
+const LIBRARY_VARIABLE_NAMES = ["unstable_settings"];
+const spelledExactly = (...alternatives) => new RegExp(`^(?:${alternatives.join("|")})$`);
+const CONVENTIONS = {
+    objectLiteralMember: {
+        match: spelledExactly(...LIBRARY_PROPERTY_NAMES, NUMERIC_KEY, AFFIXED_NAME),
+        formats: ANY_CASE,
+        label: "object property",
+    },
+    typeMember: {
+        match: spelledExactly(AFFIXED_NAME),
+        formats: ANY_CASE,
+        label: "type member",
+    },
+    variable: {
+        match: spelledExactly(...LIBRARY_VARIABLE_NAMES, AFFIXED_NAME),
+        formats: ["camelCase", "CONSTANT_CASE", "PascalCase"],
+        label: "variable",
+    },
+    enumMember: {
+        match: null,
+        formats: ["CONSTANT_CASE", "PascalCase"],
+        label: "enum member",
+    },
+};
+const matchesFormat = (format, name) => FORMAT_TESTS[format]?.(name) === true;
+const memberName = (key) => {
+    if (!key)
+        return null;
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type !== "Literal")
+        return null;
+    if (typeof key.value === "string")
+        return IDENTIFIER_NAME.test(key.value) ? key.value : null;
+    if (typeof key.value === "number")
+        return key.raw ?? String(key.value);
+    return null;
+};
+const namingViolation = (name, kind) => {
+    const convention = CONVENTIONS[kind];
+    const wrongFormat = `Rename this ${convention.label} \`${name}\` to ${convention.formats.join(", ")}.`;
+    if (convention.match === null) {
+        return convention.formats.some(format => matchesFormat(format, name)) ? null : wrongFormat;
+    }
+    const matched = convention.match.exec(name);
+    if (!matched) {
+        return `Rename this ${convention.label} \`${name}\` to a plain ${convention.formats.join("/")} identifier, with at most a leading \`_\` or a trailing \`$\`.`;
+    }
+    const captured = matched[1];
+    if (!captured)
+        return null;
+    return convention.formats.some(format => matchesFormat(format, captured)) ? null : wrongFormat;
+};
+export const noNamingConvention = problem("Require a variable, object property, type member or enum member to use one of the casings allowed for its kind.", {
+    createOnce(context) {
+        const check = (node, name, kind) => {
+            if (name === null)
+                return;
+            const message = namingViolation(name, kind);
+            if (message !== null)
+                context.report({ node, message });
+        };
+        const checkBinding = (node, shorthand) => {
+            if (!node)
+                return;
+            switch (node.type) {
+                case "Identifier": {
+                    if (shorthand || PLACEHOLDER_NAME.test(node.name))
+                        return;
+                    check(node, node.name, "variable");
+                    return;
+                }
+                case "AssignmentPattern":
+                    checkBinding(node.left, shorthand);
+                    return;
+                case "RestElement":
+                    checkBinding(node.argument, false);
+                    return;
+                case "ArrayPattern": {
+                    for (const element of node.elements)
+                        checkBinding(element, false);
+                    return;
+                }
+                case "ObjectPattern": {
+                    for (const property of node.properties) {
+                        if (property.type === "RestElement")
+                            checkBinding(property.argument, false);
+                        else
+                            checkBinding(property.value, property.shorthand);
+                    }
+                    return;
+                }
+                default:
+                    return;
+            }
+        };
+        return {
+            VariableDeclarator(node) {
+                checkBinding(node.id, false);
+            },
+            Property(node) {
+                if (node.computed || node.parent.type === "ObjectPattern")
+                    return;
+                check(node.key, memberName(node.key), "objectLiteralMember");
+            },
+            TSPropertySignature(node) {
+                if (node.computed)
+                    return;
+                check(node.key, memberName(node.key), "typeMember");
+            },
+            TSMethodSignature(node) {
+                if (node.computed)
+                    return;
+                check(node.key, memberName(node.key), "typeMember");
+            },
+            TSEnumMember(node) {
+                check(node.id, memberName(node.id), "enumMember");
+            },
+        };
+    },
+});

package/dist/core/rules/core/use-design-system.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const useDesignSystem: Rule;

package/dist/core/rules/core/use-design-system.js

@@ -0,0 +1,147 @@
+import { readdirSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { optionsOf } from "../../../lib/ast.js";
+const DESIGN_SYSTEM_DIR = "src/components/ui";
+const DESIGN_SYSTEM_ALIAS = "@/components/ui";
+const PLATFORM_SUFFIX = /\.(?:ios|android|native|web)$/;
+const LEGACY_EQUIVALENTS = {
+    Pressable: ["TouchableOpacity", "TouchableHighlight", "TouchableWithoutFeedback", "TouchableNativeFeedback"],
+};
+const NAME_OR_NAMES = { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] };
+/** What one `use` entry may be. Declared here so oxlint rejects a typo'd key instead of silently dropping the ban. */
+const USE_ENTRY_SCHEMA = {
+    anyOf: [
+        ...NAME_OR_NAMES.anyOf,
+        {
+            type: "object",
+            properties: {
+                replaces: NAME_OR_NAMES,
+                from: { type: "string" },
+                path: { type: "string" },
+                reason: { type: "string" },
+            },
+            required: ["replaces"],
+            additionalProperties: false,
+        },
+    ],
+};
+const toPascalCase = (name) => name
+    .split("-")
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+const toKebabCase = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const addBan = (banned, sourceModule, imported, replacement) => {
+    const byImportName = banned.get(sourceModule) ?? new Map();
+    byImportName.set(imported, replacement);
+    banned.set(sourceModule, byImportName);
+};
+const scanDesignSystem = (banned, dir, alias) => {
+    let files;
+    try {
+        files = readdirSync(isAbsolute(dir) ? dir : join(process.cwd(), dir));
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        if (!file.endsWith(".tsx"))
+            continue;
+        const base = file.slice(0, -4).replace(PLATFORM_SUFFIX, "");
+        if (base === "index")
+            continue;
+        const name = toPascalCase(base);
+        const from = `${alias}/${base}`;
+        addBan(banned, "react-native", name, { name, from });
+        for (const legacy of LEGACY_EQUIVALENTS[name] ?? [])
+            addBan(banned, "react-native", legacy, { name, from });
+    }
+};
+const applyUse = (banned, alias, use) => {
+    for (const [component, entry] of Object.entries(use)) {
+        const config = typeof entry === "string" || Array.isArray(entry) ? { replaces: entry } : entry;
+        const replacement = {
+            name: component,
+            from: config.path ?? `${alias}/${toKebabCase(component)}`,
+            reason: config.reason,
+        };
+        for (const imported of [config.replaces].flat()) {
+            addBan(banned, config.from ?? "react-native", imported, replacement);
+        }
+    }
+};
+const designSystems = new Map();
+const isExemptFile = (filename, exempt) => !!filename && exempt.some(fragment => filename.includes(fragment));
+const designSystemFor = (options) => {
+    const dir = options.dir ?? DESIGN_SYSTEM_DIR;
+    const alias = options.alias ?? DESIGN_SYSTEM_ALIAS;
+    const exempt = options.exempt ?? [dir];
+    const cacheKey = JSON.stringify([dir, alias, options.use]);
+    let banned = designSystems.get(cacheKey);
+    if (banned === undefined) {
+        banned = new Map();
+        scanDesignSystem(banned, dir, alias);
+        if (options.use)
+            applyUse(banned, alias, options.use);
+        designSystems.set(cacheKey, banned);
+    }
+    return { banned, exempt };
+};
+export const useDesignSystem = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow importing a raw primitive your design system already wraps. Wrapped components come from scanning the design-system directory, plus the explicit `use` map for names, paths and source modules the scan cannot infer. Files under the design-system directory (or `exempt`) are skipped.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    dir: { type: "string", minLength: 1 },
+                    alias: { type: "string", minLength: 1 },
+                    use: { type: "object", additionalProperties: USE_ENTRY_SCHEMA },
+                    exempt: { type: "array", items: { type: "string" } },
+                },
+                additionalProperties: false,
+            },
+        ],
+        defaultOff: true,
+    },
+    createOnce(context) {
+        let banned = new Map();
+        return {
+            before() {
+                const options = optionsOf(context, {});
+                const designSystem = designSystemFor(options);
+                banned = designSystem.banned;
+                if (banned.size === 0)
+                    return false;
+                const { filename } = context;
+                if (isExemptFile(filename, designSystem.exempt))
+                    return false;
+                return true;
+            },
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                const bySource = banned.get(source);
+                if (bySource === undefined)
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const { imported } = specifier;
+                    if (imported.type !== "Identifier")
+                        continue;
+                    const replacement = bySource.get(imported.name);
+                    if (replacement === undefined)
+                        continue;
+                    const reason = replacement.reason ? ` ${replacement.reason}` : "";
+                    context.report({
+                        node: specifier,
+                        message: `Import \`${replacement.name}\` from "${replacement.from}" instead of \`${imported.name}\` from ${source}. The wrapper is where the theme tokens and app behavior live.${reason}`,
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/core/rules/zod/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/core/rules/zod/index.js

@@ -0,0 +1,12 @@
+import { defineModule } from "../../../lib/module.js";
+import { preferEnum } from "./prefer-enum.js";
+export default defineModule({
+    meta: { name: "@ashstack/zod" },
+    url: import.meta.url,
+    packages: ["zod"],
+    option: "zod",
+    docsWhen: "auto-enabled when `zod` is a dependency",
+    rules: {
+        "prefer-enum": preferEnum,
+    },
+});

package/dist/core/rules/zod/prefer-enum.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const preferEnum: Rule;

package/dist/core/rules/zod/prefer-enum.js

@@ -0,0 +1,44 @@
+import { problem } from "../../../lib/ast.js";
+const MESSAGES = {
+    nativeEnum: "Call `z.enum()` here — it takes the same native enum object and params, and `z.nativeEnum()` is deprecated in Zod 4.",
+    literalUnion: "Replace this union with `z.enum([...])` listing the same string values, so invalid input reports one issue and the options stay reusable.",
+};
+const isZodCall = (node, method) => {
+    const { callee } = node;
+    if (callee.type !== "MemberExpression")
+        return false;
+    const { object, property } = callee;
+    if (object.type !== "Identifier" || object.name !== "z")
+        return false;
+    return property.type === "Identifier" && property.name === method;
+};
+const isStringLiteralCall = (node) => {
+    if (node?.type !== "CallExpression" || !isZodCall(node, "literal"))
+        return false;
+    const args = node.arguments;
+    if (args.length !== 1)
+        return false;
+    const [first] = args;
+    return first?.type === "Literal" && typeof first.value === "string";
+};
+export const preferEnum = problem("Disallow `z.nativeEnum()` and any `z.union()` whose members are all `z.literal()` strings.", {
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (isZodCall(node, "nativeEnum")) {
+                    context.report({ node, message: MESSAGES.nativeEnum });
+                    return;
+                }
+                if (!isZodCall(node, "union"))
+                    return;
+                const [members] = node.arguments;
+                if (members?.type !== "ArrayExpression")
+                    return;
+                const { elements } = members;
+                if (elements.length === 0 || !elements.every(element => isStringLiteralCall(element)))
+                    return;
+                context.report({ node, message: MESSAGES.literalUnion });
+            },
+        };
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as core, coreModules } from "./core/index.js";
+export { default as react, reactModules } from "./react/index.js";
+export { default as reactNative, reactNativeModules, banGroups } from "./react-native/index.js";
+export type { CoreOptions, ReactOptions, ReactNativeOptions, ModuleManifest } from "./lib/types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default as core, coreModules } from "./core/index.js";
+export { default as react, reactModules } from "./react/index.js";
+export { default as reactNative, reactNativeModules, banGroups } from "./react-native/index.js";

package/dist/lib/ast.d.ts

@@ -0,0 +1,44 @@
+import type { AstNode, Rule, RuleBody, RuleContext, Visitor } from "./types.js";
+type Predicate = (node: AstNode) => boolean;
+export declare const findInSubtree: (node: unknown, predicate: Predicate) => AstNode | null;
+export declare const subtreeHas: (node: unknown, predicate: Predicate) => boolean;
+/** The called name: `foo()` and `a.b.foo()` both read as `foo`; anything else is `""`. */
+export declare const calleeName: (node: AstNode | null | undefined) => string;
+/** Every ancestor of `node`, innermost first. */
+export declare const ancestors: (node: AstNode) => Generator<AstNode>;
+export declare const enclosingCall: (node: AstNode, names: ReadonlySet<string>) => AstNode | null;
+export declare const closestAncestor: (node: AstNode, types: ReadonlySet<string>) => AstNode | null;
+export declare const hasAncestor: (node: AstNode, predicate: Predicate) => boolean;
+export declare const isWithin: (node: AstNode, container: AstNode) => boolean;
+export declare const crossesFunctionBefore: (node: AstNode, container: AstNode, functionTypes: ReadonlySet<string>) => boolean;
+export declare const isMemberCall: (node: AstNode | null | undefined, method: string) => boolean;
+/** The object a method call hangs off: `store.get()` reads as `store`. */
+export declare const receiverName: (node: AstNode | null | undefined) => string | null;
+/** The last segment of a JSX tag name: `Animated.View` reads as `View`. */
+export declare const tagIdentifier: (node: AstNode | null | undefined) => string;
+/** The full dotted JSX tag name: `Animated.View` reads as `Animated.View`. Empty when a segment is not a plain name. */
+export declare const tagPath: (node: AstNode | null | undefined) => string;
+/**
+ * Which component a tag names, seeing through animation wrappers and nothing
+ * else: `Animated.View` and `AnimatedView` both read as `View`, while
+ * `Ui.View` reads as `""` — a different component that merely ends in `View`.
+ */
+export declare const componentName: (node: AstNode | null | undefined) => string;
+export declare const attributeName: (attribute: AstNode) => string;
+export declare const importedSpecifiers: (node: AstNode, source: string) => AstNode[];
+/** Function-ish node types, for ancestor walks. */
+export declare const FUNCTION_TYPES: Set<string>;
+/** Component or hook name: `Capitalized` or `useX`. */
+export declare const COMPONENT_OR_HOOK: RegExp;
+export declare const isFunction: (node: AstNode | null | undefined) => boolean;
+/** Source-text gate for createOnce rules: skip whole files that cannot contain the pattern. */
+export declare const gate: (context: RuleContext, ...markers: string[]) => boolean;
+/**
+ * A rule's first option object, or `fallback` when the consumer passed none.
+ * oxlint types options as untyped JSON, so this is the one place a rule's
+ * option shape is asserted rather than checked.
+ */
+export declare const optionsOf: <T extends object>(context: RuleContext, fallback: T) => T;
+/** Shorthand for a problem rule with a description. */
+export declare const problem: (description: string, rule: RuleBody) => Rule;
+export type { AstNode, Rule, Visitor };

package/dist/lib/ast.js

@@ -0,0 +1,162 @@
+const SKIPPED_KEYS = new Set(["parent", "loc", "range", "start", "end", "type"]);
+const findInEach = (values, predicate) => {
+    for (const value of values) {
+        const found = findInSubtree(value, predicate);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const childValues = (node) => {
+    const values = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (SKIPPED_KEYS.has(key))
+            continue;
+        if (value !== null && typeof value === "object")
+            values.push(value);
+    }
+    return values;
+};
+export const findInSubtree = (node, predicate) => {
+    if (node === null || typeof node !== "object")
+        return null;
+    if (Array.isArray(node))
+        return findInEach(node, predicate);
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const candidate = node;
+    if (typeof candidate.type !== "string")
+        return null;
+    if (predicate(candidate))
+        return candidate;
+    return findInEach(childValues(candidate), predicate);
+};
+export const subtreeHas = (node, predicate) => findInSubtree(node, predicate) !== null;
+/** The called name: `foo()` and `a.b.foo()` both read as `foo`; anything else is `""`. */
+export const calleeName = (node) => {
+    if (node?.type !== "CallExpression")
+        return "";
+    const { callee } = node;
+    if (callee.type === "Identifier")
+        return callee.name;
+    if (callee.type === "MemberExpression" && callee.property.type === "Identifier")
+        return callee.property.name;
+    return "";
+};
+/** Every ancestor of `node`, innermost first. */
+export const ancestors = function* (node) {
+    let current = node.parent;
+    while (current) {
+        yield current;
+        current = current.parent;
+    }
+};
+export const enclosingCall = (node, names) => {
+    for (const current of ancestors(node)) {
+        if (current.type === "CallExpression" && names.has(calleeName(current)))
+            return current;
+    }
+    return null;
+};
+export const closestAncestor = (node, types) => {
+    for (const current of ancestors(node)) {
+        if (types.has(current.type))
+            return current;
+    }
+    return null;
+};
+export const hasAncestor = (node, predicate) => {
+    for (const current of ancestors(node)) {
+        if (predicate(current))
+            return true;
+    }
+    return false;
+};
+export const isWithin = (node, container) => {
+    for (const current of ancestors(node)) {
+        if (current === container)
+            return true;
+    }
+    return false;
+};
+export const crossesFunctionBefore = (node, container, functionTypes) => {
+    for (const current of ancestors(node)) {
+        if (current === container)
+            return false;
+        if (functionTypes.has(current.type))
+            return true;
+    }
+    return false;
+};
+export const isMemberCall = (node, method) => node?.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === method;
+/** The object a method call hangs off: `store.get()` reads as `store`. */
+export const receiverName = (node) => {
+    if (node?.type !== "CallExpression" || node.callee.type !== "MemberExpression")
+        return null;
+    const { object } = node.callee;
+    return object.type === "Identifier" ? object.name : null;
+};
+/** The last segment of a JSX tag name: `Animated.View` reads as `View`. */
+export const tagIdentifier = (node) => {
+    let current = node;
+    while (current?.type === "JSXMemberExpression")
+        current = current.property;
+    if (current?.type === "JSXIdentifier" || current?.type === "Identifier")
+        return current.name;
+    return "";
+};
+/** The full dotted JSX tag name: `Animated.View` reads as `Animated.View`. Empty when a segment is not a plain name. */
+export const tagPath = (node) => {
+    if (node?.type === "JSXIdentifier" || node?.type === "Identifier")
+        return node.name;
+    if (node?.type !== "JSXMemberExpression")
+        return "";
+    const object = tagPath(node.object);
+    const property = tagPath(node.property);
+    return object === "" || property === "" ? "" : `${object}.${property}`;
+};
+/** Namespaces and name prefixes that wrap a component without changing which component it is. */
+const WRAPPER_PREFIX = /^(?:Animated|Reanimated)/;
+/**
+ * Which component a tag names, seeing through animation wrappers and nothing
+ * else: `Animated.View` and `AnimatedView` both read as `View`, while
+ * `Ui.View` reads as `""` — a different component that merely ends in `View`.
+ */
+export const componentName = (node) => {
+    const path = tagPath(node);
+    const dot = path.lastIndexOf(".");
+    if (dot !== -1)
+        return WRAPPER_PREFIX.test(path.slice(0, dot)) ? path.slice(dot + 1) : "";
+    const unwrapped = path.replace(WRAPPER_PREFIX, "");
+    return unwrapped === "" ? path : unwrapped;
+};
+export const attributeName = (attribute) => {
+    if (attribute.type !== "JSXAttribute")
+        return "";
+    const { name } = attribute;
+    return name.type === "JSXIdentifier" ? name.name : name.name.name;
+};
+export const importedSpecifiers = (node, source) => node.type === "ImportDeclaration" && node.source.value === source ? [...node.specifiers] : [];
+/** Function-ish node types, for ancestor walks. */
+export const FUNCTION_TYPES = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+/** Component or hook name: `Capitalized` or `useX`. */
+export const COMPONENT_OR_HOOK = /^(?:[A-Z]|use[A-Z])/;
+export const isFunction = (node) => !!node && FUNCTION_TYPES.has(node.type);
+/** Source-text gate for createOnce rules: skip whole files that cannot contain the pattern. */
+export const gate = (context, ...markers) => markers.some(marker => context.sourceCode.text.includes(marker));
+/**
+ * A rule's first option object, or `fallback` when the consumer passed none.
+ * oxlint types options as untyped JSON, so this is the one place a rule's
+ * option shape is asserted rather than checked.
+ */
+export const optionsOf = (context, fallback) => 
+// oxlint-disable-next-line typescript/no-unsafe-type-assertion
+context.options[0] ?? fallback;
+/** Shorthand for a problem rule with a description. */
+export const problem = (description, rule) => ({
+    ...rule,
+    meta: { type: "problem", ...rule.meta, docs: { description } },
+});

package/dist/lib/detect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Should this rule group ship enabled? An explicit option wins; otherwise the
+ * group is on when one of `packages` is a dependency, and always on when
+ * `packages` is absent. Dependencies come from every package.json between the
+ * current working directory and the repo boundary — the directory holding
+ * `.git` — so in a monorepo the app package, the workspace root, or both
+ * count, and a stray package.json above the repo cannot enable anything.
+ */
+export declare const detect: (option: boolean | undefined, packages: string[] | undefined) => boolean;

package/dist/lib/detect.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const dependencyNamesIn = (dir) => {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies });
+    }
+    catch {
+        return [];
+    }
+};
+const isRepoBoundary = (dir) => existsSync(join(dir, ".git"));
+const dependenciesByStartDir = new Map();
+const dependenciesUpToRepoBoundary = () => {
+    const start = process.cwd();
+    const cached = dependenciesByStartDir.get(start);
+    if (cached)
+        return cached;
+    const dependencies = new Set();
+    let dir = start;
+    for (;;) {
+        for (const name of dependencyNamesIn(dir))
+            dependencies.add(name);
+        if (isRepoBoundary(dir))
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    dependenciesByStartDir.set(start, dependencies);
+    return dependencies;
+};
+/**
+ * Should this rule group ship enabled? An explicit option wins; otherwise the
+ * group is on when one of `packages` is a dependency, and always on when
+ * `packages` is absent. Dependencies come from every package.json between the
+ * current working directory and the repo boundary — the directory holding
+ * `.git` — so in a monorepo the app package, the workspace root, or both
+ * count, and a stray package.json above the repo cannot enable anything.
+ */
+export const detect = (option, packages) => option ?? (packages === undefined || packages.some(name => dependenciesUpToRepoBoundary().has(name)));

package/dist/lib/merge.d.ts

@@ -0,0 +1,9 @@
+import type { OxlintConfig } from "./types.js";
+/**
+ * Layer `delta` over `base` into one flat config — the way `react` is built
+ * from `core` plus a react delta. Plugin lists union, `overrides` append,
+ * `rules` and the other keyed blocks are last-wins per key. Entries compose
+ * with this rather than oxlint's `extends` so every entry is a single
+ * inspectable object and a consumer's own overrides stay trivial.
+ */
+export declare const mergeConfigs: (base: OxlintConfig, delta: OxlintConfig) => OxlintConfig;

package/dist/lib/merge.js

@@ -0,0 +1,18 @@
+/**
+ * Layer `delta` over `base` into one flat config — the way `react` is built
+ * from `core` plus a react delta. Plugin lists union, `overrides` append,
+ * `rules` and the other keyed blocks are last-wins per key. Entries compose
+ * with this rather than oxlint's `extends` so every entry is a single
+ * inspectable object and a consumer's own overrides stay trivial.
+ */
+export const mergeConfigs = (base, delta) => ({
+    ...base,
+    ...delta,
+    plugins: [...new Set([...(base.plugins ?? []), ...(delta.plugins ?? [])])],
+    jsPlugins: [...new Set([...(base.jsPlugins ?? []), ...(delta.jsPlugins ?? [])])],
+    env: { ...base.env, ...delta.env },
+    globals: { ...base.globals, ...delta.globals },
+    categories: { ...base.categories, ...delta.categories },
+    rules: { ...base.rules, ...delta.rules },
+    overrides: [...(base.overrides ?? []), ...(delta.overrides ?? [])],
+});