pickier 0.1.67 → 0.1.69

package/dist/src/native.d.ts

@@ -0,0 +1,64 @@
+import type { LintIssue, LintOptions, PickierConfig } from './types';
+/** What the run's settings ask of a code file, or every rule involved. */
+export declare function nativeRequest(cfg: PickierConfig): { request: NativeRequest, ruleIds: string[] };
+/** Files the native engine lints: what the TypeScript linter treats as code. */
+export declare function isNativeFile(path: string): boolean;
+/**
+ * How the native engine takes part in a run, or null when it cannot: no
+ * binary, a run that fixes or formats, PICKIER_NATIVE=0, a custom plugin
+ * under a built-in plugin's name, or no rule it runs.
+ */
+export declare function nativePlan(cfg: PickierConfig, options: LintOptions): NativePlan | null;
+/**
+ * The native binary: $PICKIER_NATIVE_BINARY, the one shipped in this package
+ * for this platform (dist/native/<platform>-<arch>, built by
+ * scripts/build-native.ts), or a development build in packages/zig. Null when
+ * there is none.
+ */
+export declare function nativeBinary(): string | null;
+/**
+ * Lint `files` natively: one entry per file, null for a file the engine left
+ * to the TypeScript linter. Null overall when the engine is unavailable or
+ * declined the request.
+ *
+ * With `positions`, each issue also carries `pos`: its rule's position in the
+ * run's plan (-1 for a built-in check), for mergeIssues.
+ */
+export declare function lintNative(files: string[], request: NativeRequest, binary: string, threads?: number, positions?: number[]): Array<LintIssue[] | null> | null;
+/** lintNative, leaving this thread free while the engine runs. */
+export declare function lintNativeAsync(files: string[], request: NativeRequest, binary: string, positions?: number[]): Promise<Array<LintIssue[] | null> | null>;
+/**
+ * One file's issues from the engine and from the TypeScript linter's run of
+ * the remaining rules, as a TypeScript-only run reports them: built-in checks
+ * first, then each rule's issues in plan order, the first of any with the same
+ * line, column and rule kept.
+ */
+export declare function mergeIssues(native: LintIssue[], typescript: LintIssue[]): LintIssue[];
+/**
+ * The native lint engine: `pickier-zig lint-batch` (packages/zig), which
+ * lints TS/JS files on every core and reports exactly what the TypeScript
+ * linter reports for them.
+ *
+ * A run's code files go to it whenever it can take part: it runs the built-in
+ * checks and every rule whose native port is verified identical (NATIVE_RULES,
+ * checked by packages/zig/scripts/parity.ts), and the TypeScript linter runs
+ * whatever rules are left on the same files at the same time; the two sets of
+ * issues are merged in the order a TypeScript-only run reports them. --fix,
+ * formatting and files the engine declines stay on the TypeScript path.
+ */
+/** Built-in checks and plugin rules whose native output matches TypeScript. */
+export declare const NATIVE_RULES: ReadonlySet<string>;
+export declare interface NativeRequest {
+  format: { quotes: 'single' | 'double', indent: number, indentStyle: 'spaces' | 'tabs' }
+  builtins: Record<string, 'error' | 'warning' | null>
+  rules: Array<{ id: string, severity: 'error' | 'warning' | null, options: unknown }>
+}
+export declare interface NativePlan {
+  request: NativeRequest
+  binary: string
+  positions: number[]
+  nativeRules: string[]
+  hybrid: boolean
+}
+/** An issue with its rule's position in the run's plan (-1: a built-in check). */
+export type PlannedIssue = LintIssue & { pos: number }

package/dist/src/parallel.d.ts

@@ -0,0 +1,17 @@
+import type { LintIssue, LintOptions } from './types';
+/**
+ * How many worker threads to lint `fileCount` files with; 0 or 1 means the
+ * main thread alone. PICKIER_WORKERS overrides the choice.
+ */
+export declare function workerThreadsFor(fileCount: number): number;
+/**
+ * Lint `files` across `count` worker threads, each running the same
+ * `lintFileForRun` the main thread does with the same config, and return the
+ * issues in file order - exactly what linting them one by one returns.
+ *
+ * Files are handed out a few at a time as workers free up. A file a worker
+ * could not finish (it failed to start, or crashed) is linted on this thread
+ * with `lintHere`, as is everything when no worker can be started. An error
+ * thrown while linting a file is rethrown here, as it would be on one thread.
+ */
+export declare function lintInWorkers(files: string[], options: LintOptions, count: number, lintHere: (file: string) => Promise<LintIssue[]>, entry?: string | null): Promise<LintIssue[][]>;

package/dist/src/plugins/lazy.d.ts

@@ -0,0 +1,10 @@
+import { LAZY_PLUGIN_RULES } from './manifest';
+import type { PickierPlugin } from '../types';
+/**
+ * The core plugins, in the same order as `getAllPlugins`, with the non-code
+ * plugins replaced by stand-ins that load on first use. A rule's plan, its
+ * options and which duplicate rule name wins are all decided from names, so
+ * they come out the same; only the loading moves to when a rule runs.
+ */
+export declare function getLazyPlugins(): PickierPlugin[];
+declare type LazyName = keyof typeof LAZY_PLUGIN_RULES;

package/dist/src/plugins/manifest.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The rules of the plugins that only apply to non-code files, by plugin, in
+ * the order each plugin declares them. `true` marks a rule with a fixer.
+ *
+ * The linter plans from this list and loads a plugin the first time one of
+ * its rules runs (see lazy.ts), so linting TypeScript never loads the
+ * Markdown, shell or package.json rules. Kept in step with the plugins by
+ * test/plugin/lazy-plugins.test.ts.
+ * @defaultValue
+ * ```ts
+ * {
+ *   markdown: {
+ *     'heading-increment': true,
+ *     'heading-style': true,
+ *     'no-missing-space-atx': true,
+ *     'no-multiple-space-atx': true,
+ *     'no-missing-space-closed-atx': false,
+ *     'no-multiple-space-closed-atx': false,
+ *     'blanks-around-headings': true,
+ *     'heading-start-left': true,
+ *     'no-duplicate-heading': false,
+ *     'single-title': true,
+ *     'no-trailing-punctuation': true,
+ *     'ul-style': true,
+ *     'list-indent': false,
+ *     'ul-indent': false,
+ *     'ol-prefix': true,
+ *     'list-marker-space': true,
+ *     'blanks-around-lists': true,
+ *     'no-trailing-spaces': true,
+ *     'no-hard-tabs': true,
+ *     'no-multiple-blanks': true,
+ *     'no-multiple-space-blockquote': true,
+ *     'no-blanks-blockquote': true,
+ *     'blanks-around-fences': true,
+ *     'single-trailing-newline': true,
+ *     'blanks-around-tables': true,
+ *     'no-reversed-links': false,
+ *     'no-bare-urls': true,
+ *     'no-space-in-links': false,
+ *     'no-empty-links': false,
+ *     'link-fragments': false,
+ *     'reference-links-images': false,
+ *     'link-image-reference-definitions': true,
+ *     'link-image-style': true,
+ *     'descriptive-link-text': false,
+ *     'line-length': false,
+ *     'commands-show-output': false,
+ *     'fenced-code-language': false,
+ *     'code-block-style': false,
+ *     'code-fence-style': true,
+ *     'no-emphasis-as-heading': true,
+ *     'no-space-in-emphasis': true,
+ *     'no-space-in-code': true,
+ *     'emphasis-style': true,
+ *     'strong-style': true,
+ *     'no-inline-html': false,
+ *     'hr-style': false,
+ *     'first-line-heading': false,
+ *     'required-headings': false,
+ *     'proper-names': false,
+ *     'no-alt-text': false,
+ *     'table-pipe-style': false,
+ *     'table-column-count': false,
+ *     'table-column-style': false
+ *   },
+ *   shell: {
+ *     'command-substitution': true,
+ *     'quote-variables': false,
+ *     'no-cd-without-check': false,
+ *     'no-eval': false,
+ *     'no-useless-cat': false,
+ *     'no-ls-parsing': false,
+ *     'no-variable-in-single-quotes': false,
+ *     'no-exit-in-subshell': false,
+ *     'shebang': false,
+ *     'indent': true,
+ *     'function-style': true,
+ *     'operator-spacing': true,
+ *     'keyword-spacing': false,
+ *     'no-trailing-semicolons': true,
+ *     'no-trailing-whitespace': true,
+ *     'prefer-double-brackets': true,
+ *     'set-options': false,
+ *     'prefer-printf': false,
+ *     'consistent-case-terminators': false,
+ *     'no-broken-redirect': false,
+ *     'heredoc-indent': false
+ *   },
+ *   spell: { 'check': false, 'check-comments': false, 'check-markdown': false },
+ *   lockfile: {
+ *     'validate-host': false,
+ *     'validate-https': false,
+ *     'validate-integrity': false,
+ *     'validate-package-names': false,
+ *     'validate-scheme': false
+ *   },
+ *   publint: {
+ *     'use-type': false,
+ *     'local-dependency': false,
+ *     'deprecated-field-jsnext': false,
+ *     'has-module-but-no-exports': false,
+ *     'field-invalid-value-type': false,
+ *     'exports-types-should-be-first': false,
+ *     'exports-default-should-be-last': false,
+ *     'exports-module-should-precede-require': false,
+ *     'exports-value-invalid': false,
+ *     'exports-missing-root-entrypoint': false,
+ *     'exports-fallback-array-use': false,
+ *     'imports-key-invalid': false,
+ *     'imports-value-invalid': false,
+ *     'imports-default-should-be-last': false,
+ *     'imports-module-should-precede-require': false,
+ *     'file-does-not-exist': false,
+ *     'file-invalid-format': false,
+ *     'module-should-be-esm': false,
+ *     'bin-file-not-executable': false,
+ *     'exports-module-should-be-esm': false
+ *   }
+ * }
+ * ```
+ */
+export declare const LAZY_PLUGIN_RULES: Record<'markdown' | 'shell' | 'spell' | 'lockfile' | 'publint', Record<string, boolean>>;

package/dist/src/plugins/utils.d.ts

@@ -1,4 +1,10 @@
 import type { RuleModule } from '../types';
 export declare function codeOnly(rule: RuleModule): RuleModule;
+/**
+ * A rule for any text file except Markdown, where spacing is syntax: two
+ * trailing spaces are a hard line break, and runs of spaces align code
+ * blocks and tables. The markdown plugin has its own rules for these.
+ */
+export declare function notMarkdown(rule: RuleModule): RuleModule;
 export declare function shellOnly(rule: RuleModule): RuleModule;
 export declare function packageJsonOnly(rule: RuleModule): RuleModule;

package/dist/src/rules/style/consistent-list-newline.d.ts

@@ -1,2 +1,4 @@
+import { tokenize } from '../../ast';
 import type { RuleModule } from '../../types';
 export declare const consistentListNewlineRule: RuleModule;
+declare type Token = ReturnType<typeof tokenize>[number];

package/dist/src/types.d.ts

@@ -80,6 +80,7 @@ export declare interface LintOptions {
   cache?: boolean
   verbose?: boolean
   _formatOnly?: boolean
+  _nativeRules?: string[]
 }
 export declare interface FormatOptions {
   write?: boolean

package/dist/src/utils.d.ts

@@ -148,5 +148,6 @@ export declare interface EnvConfig {
   readonly DIAGNOSTICS: boolean
   readonly FAIL_ON_WARNINGS: boolean
   readonly NO_AUTO_CONFIG: boolean
+  readonly WORKERS: number | null
 }
 declare type IgnoreMatcher = (absPath: string) => boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pickier",
   "type": "module",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "Format, lint and more in a fraction of seconds.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -41,6 +41,7 @@
   "scripts": {
     "build": "bun --bun build.ts",
     "build:bin": "bun --bun build.ts && bun run compile",
+    "build:native": "bun scripts/build-native.ts",
     "compile": "bun build ./bin/cli.ts --compile --minify --outfile bin/pickier",
     "compile:all": "bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:linux-x64-musl && bun run compile:linux-arm64-musl && bun run compile:windows-x64 && bun run compile:windows-arm64 && bun run compile:darwin-x64 && bun run compile:darwin-arm64",
     "compile:linux-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-x64 --outfile bin/pickier-linux-x64",
@@ -61,7 +62,7 @@
     "zip:windows-arm64": "zip -j bin/pickier-windows-arm64.zip bin/pickier-windows-arm64.exe",
     "zip:darwin-x64": "zip -j bin/pickier-darwin-x64.zip bin/pickier-darwin-x64",
     "zip:darwin-arm64": "zip -j bin/pickier-darwin-arm64.zip bin/pickier-darwin-arm64",
-    "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
+    "prepublishOnly": "bun --bun run build && bun scripts/build-native.ts --required && bun run compile:all && bun run zip",
     "test": "PICKIER_NO_AUTO_CONFIG=1 bun test --coverage",
     "test:core": "PICKIER_NO_AUTO_CONFIG=1 bun test test/core",
     "test:format": "PICKIER_NO_AUTO_CONFIG=1 bun test test/format",