oxlint-frontier-style 1.0.0 → 1.1.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Steve Brand
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2026 Steve Brand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -28,6 +28,11 @@ All declarations must follow the following order:
 
 This order apparently makes natural sense to some developers.
 
+_Configurable_:
+
+- `exceptions` match against literal names (e.g. `RULE`, `COMPONENT`, `TRANSFORMER`)
+- `exceptionPatterns` match against RegEx patterns (e.g. `.*_OUTPUT` to except names like `DATA_OUTPUT`)
+
 ### `SCREAMING_SNAKE_CASE` for module-level constants
 
 All module-level constants must be spelled in `SCREAMING_SNAKE_CASE`.

package/dist/rules/module-const-screaming-snake.d.ts

@@ -13,22 +13,22 @@ declare const _default: {
             notScreamingSnake: string;
         };
         schema: {
-            type: "object";
-            properties: {
-                exceptions: {
-                    type: "array";
-                    items: {
-                        type: "string";
+            readonly type: "object";
+            readonly properties: {
+                readonly exceptions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
                     };
                 };
-                exceptionPatterns: {
-                    type: "array";
-                    items: {
-                        type: "string";
+                readonly exceptionPatterns: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
                     };
                 };
             };
-            additionalProperties: false;
+            readonly additionalProperties: false;
         }[];
     };
     create(context: Context): Visitor;

package/dist/rules/module-const-screaming-snake.js

@@ -2,6 +2,7 @@
  * @file Rule: module-level `const` identifiers must be `SCREAMING_SNAKE_CASE`.
  */
 import { asVariableDeclaration, unwrapExport } from "../shared/ast.js";
+import { EXCEPTION_SCHEMA, makeIsExceptedName, parseExceptionOptions, } from "../shared/exceptions.js";
 /**
  * Rule identifier, used to prefix option-validation errors.
  */
@@ -31,56 +32,6 @@ function asIdentifier(node) {
 function isExemptInitializer(init) {
     return init !== null && EXEMPT_INIT_TYPES.has(init.type);
 }
-/**
- * Whether a value is an array whose every element is a string.
- */
-function isStringArray(value) {
-    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
-}
-/**
- * Throws if `pattern` is not a valid regular expression source.
- */
-function assertValidPattern(pattern) {
-    try {
-        new RegExp(pattern);
-    }
-    catch (error) {
-        throw new SyntaxError(`${RULE_ID}: invalid \`exceptionPatterns\` entry ${JSON.stringify(pattern)}: ${error.message}`);
-    }
-}
-/**
- * Parses the raw first config element into typed options.
- *
- * The plugin interface types options as arbitrary JSON, so the shape declared by `meta.schema` is not guaranteed at runtime.
- */
-function parseOptions(raw) {
-    if (raw === undefined || raw === null)
-        return {};
-    if (typeof raw !== "object" || Array.isArray(raw))
-        throw new TypeError(`${RULE_ID}: options must be an object, received ${Array.isArray(raw) ? "array" : typeof raw}.`);
-    const { exceptions, exceptionPatterns, ...rest } = raw;
-    const unknownKeys = Object.keys(rest);
-    if (unknownKeys.length > 0)
-        throw new TypeError(`${RULE_ID}: unknown option(s): ${unknownKeys.join(", ")}.`);
-    if (exceptions !== undefined && !isStringArray(exceptions))
-        throw new TypeError(`${RULE_ID}: \`exceptions\` must be an array of strings.`);
-    if (exceptionPatterns !== undefined && !isStringArray(exceptionPatterns))
-        throw new TypeError(`${RULE_ID}: \`exceptionPatterns\` must be an array of strings.`);
-    for (const pattern of exceptionPatterns ?? [])
-        assertValidPattern(pattern);
-    return { exceptions, exceptionPatterns };
-}
-/**
- * Builds a predicate that reports whether a name is exempt by literal name or matching pattern.
- */
-function makeIsExceptedName(options) {
-    const exceptions = new Set(options.exceptions ?? []);
-    const patterns = (options.exceptionPatterns ?? []).map((pattern) => new RegExp(pattern));
-    return function isExceptedName(name) {
-        return (exceptions.has(name) ||
-            patterns.some((pattern) => pattern.test(name)));
-    };
-}
 /**
  * Reports any module-level `const` identifier that is neither exempt nor `SCREAMING_SNAKE_CASE`.
  */
@@ -117,22 +68,10 @@ export default {
         messages: {
             notScreamingSnake: "Module-level constant `{{name}}` must be SCREAMING_SNAKE_CASE.",
         },
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: { type: "array", items: { type: "string" } },
-                    exceptionPatterns: {
-                        type: "array",
-                        items: { type: "string" },
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
+        schema: [EXCEPTION_SCHEMA],
     },
     create(context) {
-        const options = parseOptions(context.options[0]);
+        const options = parseExceptionOptions(context.options[0], RULE_ID);
         const isExceptedName = makeIsExceptedName(options);
         return {
             Program(node) {

package/dist/rules/module-structure-order.d.ts

@@ -12,6 +12,24 @@ declare const _default: {
         messages: {
             outOfOrder: string;
         };
+        schema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly exceptions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly exceptionPatterns: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        }[];
     };
     create(context: Context): Visitor;
 };

package/dist/rules/module-structure-order.js

@@ -2,6 +2,11 @@
  * @file Rule: enforce top-level declaration order.
  */
 import { asVariableDeclaration, isExportStatement, unwrapExport, } from "../shared/ast.js";
+import { EXCEPTION_SCHEMA, makeIsExceptedName, parseExceptionOptions, } from "../shared/exceptions.js";
+/**
+ * Rule identifier, used to prefix option-validation errors.
+ */
+const RULE_ID = "module-structure-order";
 /**
  * Human-readable labels for each declaration rank, keyed by descending priority.
  */
@@ -52,12 +57,39 @@ function rankOf(node) {
     }
     return rankOfDeclaration(node);
 }
+/**
+ * Returns the identifier names a top-level statement binds, unwrapping any export.
+ *
+ * Returns an empty array for statements with no simple bound name, including any variable statement that binds via destructuring (those bindings cannot be matched).
+ */
+function declaredNames(node) {
+    const inner = unwrapExport(node);
+    if (inner.type === "FunctionDeclaration" ||
+        inner.type === "TSTypeAliasDeclaration" ||
+        inner.type === "TSInterfaceDeclaration")
+        return inner.id === null ? [] : [inner.id.name];
+    const declaration = asVariableDeclaration(inner);
+    if (declaration === null)
+        return [];
+    const names = [];
+    for (const declarator of declaration.declarations) {
+        if (declarator.id.type !== "Identifier")
+            return [];
+        names.push(declarator.id.name);
+    }
+    return names;
+}
 /**
  * Walks the program body and reports any statement whose rank falls below a rank already seen.
+ *
+ * Statements whose every bound name is excepted are skipped entirely.
  */
-function checkProgram(context, node) {
+function checkProgram(context, node, isExceptedName) {
     let maxRank = 0;
     for (const statement of node.body) {
+        const names = declaredNames(statement);
+        if (names.length > 0 && names.every(isExceptedName))
+            continue;
         const rank = rankOf(statement);
         if (rank === null)
             continue;
@@ -85,11 +117,14 @@ export default {
         messages: {
             outOfOrder: "{{kind}} are out of order. Expected: imports, types, interfaces, const, let, functions, exports.",
         },
+        schema: [EXCEPTION_SCHEMA],
     },
     create(context) {
+        const options = parseExceptionOptions(context.options[0], RULE_ID);
+        const isExceptedName = makeIsExceptedName(options);
         return {
             Program(node) {
-                checkProgram(context, node);
+                checkProgram(context, node, isExceptedName);
             },
         };
     },

package/dist/shared/exceptions.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Shared exception-list options: literal and pattern name matching reused across rules.
+ */
+/**
+ * Options for an exception list, passed as the first config element.
+ */
+export interface ExceptionOptions {
+    /** Exceptions matched by literal value. */
+    exceptions?: string[];
+    /** Exceptions matched with a regex pattern. */
+    exceptionPatterns?: string[];
+}
+/**
+ * JSON Schema for the exception-list options object.
+ */
+export declare const EXCEPTION_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly exceptions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly exceptionPatterns: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly additionalProperties: false;
+};
+/**
+ * Parses the raw first config element into typed exception options.
+ *
+ * The plugin interface types options as arbitrary JSON, so the shape declared by `meta.schema` is not guaranteed at runtime.
+ */
+export declare function parseExceptionOptions(raw: unknown, ruleId: string): ExceptionOptions;
+/**
+ * Builds a predicate that reports whether a name is exempt by literal name or matching pattern.
+ */
+export declare function makeIsExceptedName(options: ExceptionOptions): (name: string) => boolean;

package/dist/shared/exceptions.js

@@ -0,0 +1,64 @@
+/**
+ * @file Shared exception-list options: literal and pattern name matching reused across rules.
+ */
+/**
+ * JSON Schema for the exception-list options object.
+ */
+export const EXCEPTION_SCHEMA = {
+    type: "object",
+    properties: {
+        exceptions: { type: "array", items: { type: "string" } },
+        exceptionPatterns: { type: "array", items: { type: "string" } },
+    },
+    additionalProperties: false,
+};
+/**
+ * Whether a value is an array whose every element is a string.
+ */
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
+/**
+ * Throws if `pattern` is not a valid regular expression source.
+ */
+function assertValidPattern(pattern, ruleId) {
+    try {
+        new RegExp(pattern);
+    }
+    catch (error) {
+        throw new SyntaxError(`${ruleId}: invalid \`exceptionPatterns\` entry ${JSON.stringify(pattern)}: ${error.message}`);
+    }
+}
+/**
+ * Parses the raw first config element into typed exception options.
+ *
+ * The plugin interface types options as arbitrary JSON, so the shape declared by `meta.schema` is not guaranteed at runtime.
+ */
+export function parseExceptionOptions(raw, ruleId) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== "object" || Array.isArray(raw))
+        throw new TypeError(`${ruleId}: options must be an object, received ${Array.isArray(raw) ? "array" : typeof raw}.`);
+    const { exceptions, exceptionPatterns, ...rest } = raw;
+    const unknownKeys = Object.keys(rest);
+    if (unknownKeys.length > 0)
+        throw new TypeError(`${ruleId}: unknown option(s): ${unknownKeys.join(", ")}.`);
+    if (exceptions !== undefined && !isStringArray(exceptions))
+        throw new TypeError(`${ruleId}: \`exceptions\` must be an array of strings.`);
+    if (exceptionPatterns !== undefined && !isStringArray(exceptionPatterns))
+        throw new TypeError(`${ruleId}: \`exceptionPatterns\` must be an array of strings.`);
+    for (const pattern of exceptionPatterns ?? [])
+        assertValidPattern(pattern, ruleId);
+    return { exceptions, exceptionPatterns };
+}
+/**
+ * Builds a predicate that reports whether a name is exempt by literal name or matching pattern.
+ */
+export function makeIsExceptedName(options) {
+    const exceptions = new Set(options.exceptions ?? []);
+    const patterns = (options.exceptionPatterns ?? []).map((pattern) => new RegExp(pattern));
+    return function isExceptedName(name) {
+        return (exceptions.has(name) ||
+            patterns.some((pattern) => pattern.test(name)));
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "oxlint-frontier-style",
-	"version": "1.0.0",
+	"version": "1.1.2",
 	"description": "oxlint plugin enforcing the Frontier code style",
 	"keywords": [
 		"oxlint",
@@ -34,6 +34,7 @@
 	"devDependencies": {
 		"@oxlint/plugins": "^1.48.0",
 		"@types/node": "^25.9.1",
+		"@typescript/native-preview": "^7.0.0-dev.20260616.1",
 		"oxfmt": "^0.54.0",
 		"oxlint": "^1.48.0",
 		"oxlint-tsgolint": "^0.23.0"