toiljs 0.0.115 → 0.0.117

package/presets/no-uint8array-tostring.js

@@ -1,54 +1,26 @@
-/**
- * ESLint rule: disallow `.toString()` on Uint8Array (and branded byte types), which returns
- * comma-separated decimals instead of hex.
- */
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { SyntaxKind } from 'typescript';
-
-function isUint8ArrayType(type, checker) {
-    const symbol = type.getSymbol();
-    if (symbol?.getName() === 'Uint8Array') {
-        return true;
-    }
-
-    const baseTypes = type.getBaseTypes?.();
-    if (baseTypes) {
-        for (const baseType of baseTypes) {
-            if (isUint8ArrayType(baseType, checker)) {
-                return true;
-            }
-        }
-    }
-
-    if (type.isIntersection()) {
-        for (const subType of type.types) {
-            if (isUint8ArrayType(subType, checker)) {
-                return true;
-            }
-        }
-    }
-
-    if (type.isUnion()) {
-        return (
-            type.types.length > 0 &&
-            type.types.every((subType) => isUint8ArrayType(subType, checker))
-        );
+/** Oxlint plugin using the TypeScript 7 native checker for branded byte arrays. */
+import path from 'node:path';
+import { API } from 'typescript/unstable/sync';
+import { SyntaxKind } from 'typescript/unstable/ast';
+
+function isUint8ArrayType(type, checker, ancestors = new Set()) {
+    if (!type || ancestors.has(type.id)) return false;
+    const seen = new Set(ancestors).add(type.id);
+    if (type.getSymbol()?.name === 'Uint8Array') return true;
+    if (type.getBaseTypes()?.some((base) => isUint8ArrayType(base, checker, seen))) return true;
+    if (type.isIntersectionType())
+        return type.getTypes().some((part) => isUint8ArrayType(part, checker, seen));
+    if (type.isUnionType()) {
+        const parts = type.getTypes();
+        return parts.length > 0 && parts.every((part) => isUint8ArrayType(part, checker, seen));
     }
-
-    const constraint = type.getConstraint?.();
-    if (constraint && isUint8ArrayType(constraint, checker)) {
-        return true;
-    }
-
-    return false;
+    const constraint = checker.getBaseConstraintOfType(type);
+    return constraint && constraint.id !== type.id
+        ? isUint8ArrayType(constraint, checker, seen)
+        : false;
 }
 
-/**
- * Types whose toString() is the dangerous default behavior we want to catch.
- * If toString is declared on any type NOT in this set, it has been
- * intentionally overridden and we should leave it alone.
- */
-const DEFAULT_TOSTRING_OWNERS = new Set([
+const DEFAULT_OWNERS = new Set([
     'Object',
     'Uint8Array',
     'Int8Array',
@@ -63,138 +35,133 @@ const DEFAULT_TOSTRING_OWNERS = new Set([
     'BigUint64Array',
 ]);
 
-/**
- * Given a declaration node, walk up the AST parents to find the enclosing
- * class or interface name. More reliable than checker.getTypeAtLocation(decl.parent),
- * which can return odd results for .d.ts files.
- */
-function getEnclosingClassName(decl) {
-    let current = decl.parent;
-    while (current) {
-        if (
-            current.kind === SyntaxKind.ClassDeclaration ||
-            current.kind === SyntaxKind.ClassExpression ||
-            current.kind === SyntaxKind.InterfaceDeclaration
-        ) {
-            if (current.name) {
-                return current.name.text;
+function hasOverride(symbol) {
+    for (const handle of symbol?.declarations ?? []) {
+        let node = handle.resolve()?.parent;
+        while (node) {
+            if (
+                [
+                    SyntaxKind.ClassDeclaration,
+                    SyntaxKind.ClassExpression,
+                    SyntaxKind.InterfaceDeclaration,
+                ].includes(node.kind)
+            ) {
+                const name = node.name?.text;
+                if (name && !DEFAULT_OWNERS.has(name)) return true;
+                break;
             }
+            node = node.parent;
         }
-
-        current = current.parent;
     }
-
-    return undefined;
+    return false;
 }
 
-/**
- * Checks whether the resolved toString() on this type is a custom override
- * rather than the default Uint8Array/Object prototype version.
- */
 function hasCustomToString(type, checker) {
-    const toStringSymbol = type.getProperty('toString');
-    if (!toStringSymbol) {
-        return false;
-    }
-
-    const declarations = toStringSymbol.getDeclarations();
-    if (!declarations || declarations.length === 0) {
-        return false;
-    }
-
-    for (const decl of declarations) {
-        const ownerName = getEnclosingClassName(decl);
-        if (ownerName && !DEFAULT_TOSTRING_OWNERS.has(ownerName)) {
-            return true;
-        }
-    }
-
-    const apparentType = checker.getApparentType(type);
-    if (apparentType !== type) {
-        const apparentToString = apparentType.getProperty('toString');
-        if (apparentToString && apparentToString !== toStringSymbol) {
-            const apparentDecls = apparentToString.getDeclarations();
-            if (apparentDecls) {
-                for (const decl of apparentDecls) {
-                    const ownerName = getEnclosingClassName(decl);
-                    if (ownerName && !DEFAULT_TOSTRING_OWNERS.has(ownerName)) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    return false;
+    if (hasOverride(checker.getPropertyOfType(type, 'toString'))) return true;
+    const apparent = checker.getApparentType(type);
+    return (
+        apparent &&
+        apparent.id !== type.id &&
+        hasOverride(checker.getPropertyOfType(apparent, 'toString'))
+    );
 }
 
-const createRule = ESLintUtils.RuleCreator(
-    (name) => `https://github.com/dacely-cloud/toiljs/tree/main/presets#${name}`,
-);
-
-const rule = createRule({
-    name: 'no-uint8array-tostring',
+export const rule = {
     meta: {
         type: 'problem',
         docs: {
             description:
-                'Disallow .toString() on Uint8Array and branded types (Script, Bytes32, etc.) which produces comma-separated decimals instead of hex',
+                'Disallow the default Uint8Array.toString(), including branded byte types.',
         },
+        schema: [],
         messages: {
             noUint8ArrayToString:
-                '{{typeName}}.toString() returns comma-separated decimals (e.g. "0,32,70,107"), not a hex string. ' +
-                'Use Buffer.from(arr).toString("hex") or toHex() instead.',
+                '{{typeName}}.toString() returns comma-separated decimals (e.g. "0,32,70,107"), not a hex string. Use Buffer.from(arr).toString("hex") or toHex() instead.',
         },
-        schema: [],
     },
-    defaultOptions: [],
     create(context) {
-        const services = ESLintUtils.getParserServices(context);
-        const checker = services.program.getTypeChecker();
-
+        const calls = [];
         return {
             CallExpression(node) {
+                const callee = node.callee;
                 if (
-                    node.callee.type !== AST_NODE_TYPES.MemberExpression ||
-                    node.callee.property.type !== AST_NODE_TYPES.Identifier ||
-                    node.callee.property.name !== 'toString' ||
-                    node.arguments.length > 0
-                ) {
-                    return;
-                }
-
-                const objectNode = node.callee.object;
-                const tsNode = services.esTreeNodeToTSNodeMap.get(objectNode);
-                const type = checker.getTypeAtLocation(tsNode);
-
-                if (!isUint8ArrayType(type, checker)) {
-                    return;
-                }
-
-                if (hasCustomToString(type, checker)) {
-                    return;
-                }
-
-                const typeName = checker.typeToString(type);
-                context.report({
-                    node,
-                    messageId: 'noUint8ArrayToString',
-                    data: { typeName },
+                    callee.type === 'MemberExpression' &&
+                    callee.property.type === 'Identifier' &&
+                    callee.property.name === 'toString' &&
+                    node.arguments.length === 0
+                )
+                    calls.push(node);
+            },
+            'Program:exit'() {
+                if (calls.length === 0) return;
+                const file = path.resolve(context.filename);
+                // Use the actual lint input, including editor buffers and fix passes.
+                const api = new API({
+                    cwd: context.cwd,
+                    fs: {
+                        readFile: (name) =>
+                            path.resolve(name) === file ? context.sourceCode.text : undefined,
+                    },
                 });
+                let snapshot;
+                try {
+                    snapshot = api.updateSnapshot({ openFiles: [file] });
+                    const project = snapshot.getDefaultProjectForFile(file);
+                    if (!project) throw new Error(`No TypeScript 7 project for ${file}`);
+                    const checker = project.checker;
+                    const source = project.program.getSourceFile(file);
+                    if (!source) throw new Error(`No TypeScript 7 source file for ${file}`);
+                    const wanted = new Map(
+                        calls.map((node) => [node.callee.object.range.join(':'), undefined]),
+                    );
+                    function visit(node) {
+                        const key = `${node.getStart(source)}:${node.end}`;
+                        if (wanted.has(key)) wanted.set(key, node);
+                        node.forEachChild(visit);
+                    }
+                    visit(source);
+                    const receivers = calls.map((node) => {
+                        const receiver = wanted.get(node.callee.object.range.join(':'));
+                        if (!receiver) throw new Error(`Cannot map byte-array receiver in ${file}`);
+                        return receiver;
+                    });
+                    const types = checker.getTypeAtLocation(receivers);
+                    for (let i = 0; i < calls.length; i++) {
+                        const type = types[i];
+                        if (isUint8ArrayType(type, checker) && !hasCustomToString(type, checker)) {
+                            context.report({
+                                node: calls[i],
+                                messageId: 'noUint8ArrayToString',
+                                data: { typeName: checker.typeToString(type) },
+                            });
+                        }
+                    }
+                } finally {
+                    snapshot?.dispose();
+                    api.close();
+                }
             },
         };
     },
-});
+};
 
-const plugin = {
-    meta: {
-        name: 'eslint-plugin-no-uint8array-tostring',
-        version: '1.0.0',
-    },
+export default {
+    meta: { name: 'toiljs', version: '2.0.0' },
     rules: {
         'no-uint8array-tostring': rule,
+        // Legacy octal literals are invalid in modules; retain this check for script inputs too.
+        'no-octal': {
+            meta: {
+                type: 'problem',
+                schema: [],
+                messages: { octal: 'Octal literals should not be used.' },
+            },
+            create: (context) => ({
+                Literal(node) {
+                    if (typeof node.value === 'number' && /^0[0-7]+$/.test(node.raw))
+                        context.report({ node, messageId: 'octal' });
+                },
+            }),
+        },
     },
 };
-
-export default plugin;
-export { rule };

package/presets/oxlint.d.ts

@@ -0,0 +1,5 @@
+import type { OxlintConfig } from 'oxlint';
+
+/** Shared strict TypeScript 7 and React configuration, including native semantic checks. */
+declare const config: OxlintConfig;
+export default config;

package/presets/oxlint.js

@@ -0,0 +1,224 @@
+// Port of the effective ESLint rules, including strict type-aware checks.
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'oxlint';
+
+export default defineConfig({
+    categories: {
+        correctness: 'off',
+    },
+    plugins: ['typescript', 'react'],
+    jsPlugins: [
+        {
+            name: 'toiljs',
+            specifier: fileURLToPath(new URL('./no-uint8array-tostring.js', import.meta.url)),
+        },
+        {
+            name: 'react-hooks-js',
+            specifier: fileURLToPath(import.meta.resolve('eslint-plugin-react-hooks')),
+        },
+        {
+            name: 'style',
+            specifier: fileURLToPath(import.meta.resolve('@stylistic/eslint-plugin')),
+        },
+    ],
+    options: {
+        typeAware: true,
+    },
+    ignorePatterns: [
+        'build/**',
+        'dist/**',
+        'node_modules/**',
+        'server/**',
+        'std/server/**',
+        'toil-env.d.ts',
+        '.toil/**',
+        'src/compiler/toil-docs.generated.ts',
+    ],
+    rules: {
+        'eslint/constructor-super': 'off',
+        'eslint/for-direction': 'error',
+        'eslint/getter-return': 'off',
+        'eslint/no-async-promise-executor': 'off',
+        'eslint/no-case-declarations': 'error',
+        'eslint/no-class-assign': 'off',
+        'eslint/no-compare-neg-zero': 'error',
+        'eslint/no-cond-assign': 'error',
+        'eslint/no-const-assign': 'off',
+        'eslint/no-constant-binary-expression': 'off',
+        'eslint/no-constant-condition': 'error',
+        'eslint/no-control-regex': 'error',
+        'eslint/no-debugger': 'error',
+        'eslint/no-delete-var': 'error',
+        'eslint/no-dupe-class-members': 'off',
+        'eslint/no-dupe-else-if': 'error',
+        'eslint/no-dupe-keys': 'off',
+        'eslint/no-duplicate-case': 'error',
+        'eslint/no-empty': 'off',
+        'eslint/no-empty-character-class': 'error',
+        'eslint/no-empty-pattern': 'error',
+        'eslint/no-empty-static-block': 'error',
+        'eslint/no-ex-assign': 'error',
+        'eslint/no-extra-boolean-cast': 'error',
+        'eslint/no-fallthrough': 'error',
+        'eslint/no-func-assign': 'off',
+        'eslint/no-global-assign': 'error',
+        'eslint/no-import-assign': 'off',
+        'eslint/no-invalid-regexp': 'error',
+        'eslint/no-irregular-whitespace': 'error',
+        'eslint/no-loss-of-precision': 'error',
+        'eslint/no-misleading-character-class': 'error',
+        'eslint/no-new-native-nonconstructor': 'off',
+        'eslint/no-nonoctal-decimal-escape': 'error',
+        'eslint/no-obj-calls': 'off',
+        'toiljs/no-octal': 'error',
+        'eslint/no-prototype-builtins': 'error',
+        'eslint/no-redeclare': 'off',
+        'eslint/no-regex-spaces': 'error',
+        'eslint/no-self-assign': 'error',
+        'eslint/no-setter-return': 'off',
+        'eslint/no-shadow-restricted-names': 'error',
+        'eslint/no-sparse-arrays': 'error',
+        'eslint/no-this-before-super': 'off',
+        'eslint/no-unassigned-vars': 'error',
+        'eslint/no-undef': 'off',
+        'eslint/no-unexpected-multiline': 'error',
+        'eslint/no-unreachable': 'off',
+        'eslint/no-unsafe-finally': 'error',
+        'eslint/no-unsafe-negation': 'off',
+        'eslint/no-unsafe-optional-chaining': 'error',
+        'eslint/no-unused-labels': 'error',
+        'eslint/no-unused-private-class-members': 'error',
+        'eslint/no-unused-vars': 'off',
+        'eslint/no-useless-assignment': 'off',
+        'eslint/no-useless-backreference': 'error',
+        'eslint/no-useless-catch': 'error',
+        'eslint/no-useless-escape': 'error',
+        'eslint/no-with': 'off',
+        'eslint/preserve-caught-error': 'error',
+        'eslint/require-yield': 'error',
+        'eslint/use-isnan': 'error',
+        'eslint/valid-typeof': 'error',
+        'eslint/no-var': 'error',
+        'eslint/prefer-const': 'error',
+        'eslint/prefer-rest-params': 'error',
+        'eslint/prefer-spread': 'off',
+        'typescript/ban-ts-comment': 'off',
+        'eslint/no-array-constructor': 'error',
+        'typescript/no-duplicate-enum-values': 'off',
+        'typescript/no-empty-object-type': 'off',
+        'typescript/no-explicit-any': 'error',
+        'typescript/no-extra-non-null-assertion': 'error',
+        'typescript/no-misused-new': 'error',
+        'typescript/no-namespace': 'error',
+        'typescript/no-non-null-asserted-optional-chain': 'error',
+        'typescript/no-require-imports': 'error',
+        'typescript/no-this-alias': 'error',
+        'typescript/no-unnecessary-type-constraint': 'error',
+        'typescript/no-unsafe-declaration-merging': 'error',
+        'typescript/no-unsafe-function-type': 'error',
+        'eslint/no-unused-expressions': 'error',
+        'typescript/no-wrapper-object-types': 'error',
+        'typescript/prefer-as-const': 'error',
+        'typescript/prefer-namespace-keyword': 'error',
+        'typescript/triple-slash-reference': 'error',
+        'typescript/await-thenable': 'error',
+        'typescript/no-array-delete': 'error',
+        'typescript/no-base-to-string': 'error',
+        'typescript/no-confusing-void-expression': 'off',
+        'typescript/no-deprecated': 'off',
+        'typescript/no-duplicate-type-constituents': 'error',
+        'typescript/no-dynamic-delete': 'error',
+        'typescript/no-extraneous-class': 'off',
+        'typescript/no-floating-promises': 'off',
+        'typescript/no-for-in-array': 'error',
+        'eslint/no-implied-eval': 'off',
+        'typescript/no-implied-eval': 'error',
+        'typescript/no-invalid-void-type': 'error',
+        'typescript/no-meaningless-void-operator': 'error',
+        'typescript/no-misused-promises': 'off',
+        'typescript/no-misused-spread': 'error',
+        'typescript/no-mixed-enums': 'error',
+        'typescript/no-non-null-asserted-nullish-coalescing': 'error',
+        'typescript/no-non-null-assertion': 'error',
+        'typescript/no-redundant-type-constituents': 'error',
+        'typescript/no-unnecessary-boolean-literal-compare': 'error',
+        'typescript/no-unnecessary-condition': 'off',
+        'typescript/no-unnecessary-template-expression': 'error',
+        'typescript/no-unnecessary-type-arguments': 'off',
+        'typescript/no-unnecessary-type-assertion': 'error',
+        'typescript/no-unnecessary-type-conversion': 'warn',
+        'typescript/no-unnecessary-type-parameters': 'off',
+        'typescript/no-unsafe-argument': 'off',
+        'typescript/no-unsafe-assignment': 'off',
+        'typescript/no-unsafe-call': 'off',
+        'typescript/no-unsafe-enum-comparison': 'error',
+        'typescript/no-unsafe-member-access': 'off',
+        'typescript/no-unsafe-return': 'error',
+        'typescript/no-unsafe-unary-minus': 'error',
+        'eslint/no-useless-constructor': 'error',
+        'typescript/no-useless-default-assignment': 'error',
+        'eslint/no-throw-literal': 'off',
+        'typescript/only-throw-error': 'off',
+        'typescript/prefer-literal-enum-member': 'error',
+        'eslint/prefer-promise-reject-errors': 'off',
+        'typescript/prefer-promise-reject-errors': 'error',
+        'typescript/prefer-reduce-type-parameter': 'error',
+        'typescript/prefer-return-this-type': 'error',
+        'typescript/related-getter-setter-pairs': 'error',
+        'eslint/require-await': 'off',
+        'typescript/require-await': 'error',
+        'typescript/restrict-plus-operands': [
+            'error',
+            {
+                allowAny: false,
+                allowBoolean: false,
+                allowNullish: false,
+                allowNumberAndString: false,
+                allowRegExp: false,
+            },
+        ],
+        'typescript/restrict-template-expressions': 'off',
+        'typescript/return-await': ['error', 'error-handling-correctness-only'],
+        'typescript/unbound-method': 'warn',
+        'typescript/unified-signatures': 'error',
+        'typescript/use-unknown-in-catch-callback-variable': 'error',
+        'react-hooks-js/rules-of-hooks': 'error',
+        'react-hooks-js/exhaustive-deps': 'warn',
+        'react-hooks-js/static-components': 'error',
+        'react-hooks-js/use-memo': 'error',
+        'react-hooks-js/preserve-manual-memoization': 'error',
+        'react-hooks-js/incompatible-library': 'warn',
+        'react-hooks-js/immutability': 'error',
+        'react-hooks-js/globals': 'error',
+        'react-hooks-js/refs': 'error',
+        'react-hooks-js/set-state-in-effect': 'warn',
+        'react-hooks-js/error-boundaries': 'error',
+        'react-hooks-js/purity': 'error',
+        'react-hooks-js/set-state-in-render': 'error',
+        'react-hooks-js/unsupported-syntax': 'warn',
+        'react-hooks-js/config': 'error',
+        'react-hooks-js/gating': 'error',
+        'react/only-export-components': [
+            'warn',
+            {
+                allowConstantExport: true,
+                allowExportNames: [
+                    'loader',
+                    'revalidate',
+                    'metadata',
+                    'generateMetadata',
+                    'searchHints',
+                ],
+            },
+        ],
+        'toiljs/no-uint8array-tostring': 'error',
+        'style/padding-line-between-statements': [
+            'error',
+            {
+                blankLine: 'always',
+                prev: 'block-like',
+                next: '*',
+            },
+        ],
+    },
+});

package/server/runtime/tsconfig.json

@@ -1,7 +1,5 @@
 {
     "extends": "toilscript/std/assembly.json",
-    "compilerOptions": {
-        "plugins": [{ "name": "toilscript/std/ts-plugin.cjs" }]
-    },
+    "compilerOptions": {},
     "include": ["./**/*.ts"]
 }

package/tsconfig.json

@@ -8,15 +8,6 @@
         "noEmit": true,
         "incremental": false
     },
-    "include": [
-        "src/**/*.ts",
-        "src/**/*.tsx",
-        "test/**/*.ts",
-        "std/client/index.d.ts"
-    ],
-    "exclude": [
-        "node_modules",
-        "build",
-        "server"
-    ]
+    "include": ["src/**/*.ts", "src/**/*.tsx", "std/client/index.d.ts"],
+    "exclude": ["node_modules", "build", "server"]
 }

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.