onsystem 0.4.0 → 0.6.0

package/dist/config-lbfW91qB.d.ts

@@ -0,0 +1,482 @@
+import * as z from "zod";
+//#region src/detect.d.ts
+/**
+ * How apps import a design-system module, from a package's `exports`:
+ * `@midday/ui/button` → `../../packages/ui/src/components/button.tsx`, or a
+ * pattern (`@workspace/ui/components/*` → `…/src/components/*.tsx`). A
+ * specifier without `*` and a pattern target map every matching file to one
+ * module: a package that exports its components from a barrel.
+ */
+interface ImportMapping {
+  specifier: string;
+  /** File or pattern relative to the root, with forward slashes. */
+  target: string;
+}
+/**
+ * A dependency whose package.json declares its onsystem config
+ * (`"onsystem": "./onsystem.config.json"`): a design-system package set up for the apps that
+ * use it.
+ */
+interface DesignSystemPackage {
+  /** Its package name: `@acme/ui`. */
+  name: string;
+  /** Its folder, absolute: the workspace package's sources, or where it is installed. */
+  dir: string;
+  /** The JSON config its package.json names, absolute. */
+  config: string;
+  /** Installed from a registry into `node_modules`, rather than a workspace package. */
+  installed: boolean;
+  /**
+   * The folder its config's paths must stay in: its own folder when installed, else the
+   * workspace root (a sibling package's tokens, `../tokens/...`), or its own folder outside one.
+   */
+  boundary: string;
+}
+/** One of several design systems an app uses, and how often its code imports it. */
+interface DesignSystemSource {
+  source: string;
+  components: string[];
+  imports: number;
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * The design-system model the server exposes. Everything here is plain JSON so
+ * it can be cached on disk and returned as MCP structured content.
+ */
+declare const TOKEN_CATEGORIES: readonly ["color", "spacing", "radius", "typography", "shadow", "other"];
+type TokenCategory = (typeof TOKEN_CATEGORIES)[number];
+interface SourceLocation {
+  /** Path relative to the project root, with forward slashes. */
+  file: string;
+  /** 1-based line. */
+  line: number;
+}
+interface Token {
+  /**
+   * Canonical name: the DTCG path for JSON tokens (`color.brand.500`) or the
+   * custom property without its dashes for CSS tokens (`primary`, `radius-md`).
+   */
+  name: string;
+  category: TokenCategory;
+  /** The value with aliases resolved, as authored (`oklch(0.205 0 0)`, `0.5rem`). */
+  value: string;
+  /** Values for other modes or themes, e.g. `{ dark: "oklch(0.922 0 0)" }`. */
+  modes?: Record<string, string>;
+  /** The custom property to reference from CSS, e.g. `--primary`. */
+  cssVar?: string;
+  /**
+   * Tailwind theme key when the token is exposed through `@theme`
+   * (`primary` for `--color-primary`, `md` for `--radius-md`).
+   */
+  tailwind?: string;
+  /** Ready-to-paste usages, most idiomatic first: `bg-primary`, `var(--primary)`. */
+  usage: string[];
+  description?: string;
+  deprecated?: string | true;
+  /** Name of the token this one aliases, if any. */
+  aliasOf?: string;
+  /**
+   * Where the value comes from. `tailwind-default` marks Tailwind built-ins such as `--spacing`;
+   * `library` a value of a library's theme (MUI's `createTheme`), whose spacing and radius are
+   * listed but do not drive the length rules, whose scales are Tailwind's.
+   */
+  origin?: 'tailwind-default' | 'library';
+  source: SourceLocation;
+}
+interface PropInfo {
+  name: string;
+  /** TypeScript type as written by the checker, without `| undefined`. */
+  type: string;
+  required: boolean;
+  default?: string;
+  description?: string;
+  /** Allowed values when the type is a finite set of literals. */
+  values?: string[];
+  deprecated?: string | true;
+  /** `variant` when the prop comes from a `cva()` definition. */
+  kind: 'prop' | 'variant';
+}
+interface VariantInfo {
+  /** Variant prop name, e.g. `variant` or `size`. */
+  name: string;
+  values: string[];
+  default?: string;
+  /** Classes applied for each value, straight from the `cva()` config. */
+  classes: Record<string, string>;
+}
+interface CompoundVariantInfo {
+  when: Record<string, string | string[]>;
+  classes: string;
+}
+interface InheritedProps {
+  /** Source text of the type the props come from, e.g. `React.ComponentProps<"button">`. */
+  from: string;
+  count: number;
+  /** Key into `DesignSystemModel.propSets` with the full list of names. */
+  set: string;
+  /** Names in the set marked `@deprecated` (React Aria's `onClick`), left out of summaries. */
+  deprecated?: string[];
+}
+interface ExampleInfo {
+  title?: string;
+  code: string;
+  lang: string;
+  source: 'docs' | 'jsdoc';
+}
+interface DocSection {
+  heading: string;
+  body: string;
+}
+interface ComponentDocs {
+  file: string;
+  description?: string;
+  sections: DocSection[];
+  frontmatter: Record<string, string | string[]>;
+}
+interface ComponentInfo {
+  /** How the component is referenced in JSX: `Button`, `CardHeader` or `Tabs.List`. */
+  name: string;
+  /** Other names that resolve to the same component (e.g. `Card.Header` when `CardHeader` is also exported). */
+  aliases: string[];
+  description?: string;
+  deprecated?: string | true;
+  /** Suggested import specifier, e.g. `@/components/ui/button`. */
+  importPath: string;
+  /** Exported binding name, or the static member path for compound members. */
+  exportName: string;
+  source: SourceLocation;
+  /** The root component this one belongs to (`Card` for `CardHeader`). */
+  parent?: string;
+  /** Direct sub-components, in declaration order. */
+  subcomponents: string[];
+  /** Native element it renders or wraps, when it can be inferred (`button`, `input`). */
+  element?: string;
+  props: PropInfo[];
+  inherits: InheritedProps[];
+  /**
+   * True when part of the props type could not be resolved (missing
+   * `node_modules`, a type error). The linter then skips unknown-prop checks.
+   */
+  openProps: boolean;
+  variants: VariantInfo[];
+  compoundVariants: CompoundVariantInfo[];
+  examples: ExampleInfo[];
+  docs?: ComponentDocs;
+  /** Utility classes used in the component source; mapped to tokens at query time. */
+  classNames: string[];
+  /** CSS custom properties referenced in the component source. */
+  cssVars: string[];
+  /**
+   * The published library it comes from, read from its type declarations rather than from
+   * source: `@mui/material`. The app's own components win where they share a name.
+   */
+  library?: string;
+  /**
+   * A prop that renders another element or component in its place and takes that one's props
+   * (`component` in MUI): when it is set, the props cannot be checked.
+   */
+  polymorphic?: string;
+  /** Another module that exports it as its default: `@mui/material/Button`. */
+  defaultImport?: string;
+  /**
+   * A prop whose text the component gives its child element as its accessible name (MUI's
+   * Tooltip `title`), unless the `unless` prop is set (`describeChild` makes it a description).
+   */
+  labelsChild?: {
+    prop: string;
+    unless?: string;
+  };
+}
+interface DesignSystemModel {
+  version: 1;
+  root: string;
+  components: ComponentInfo[];
+  tokens: Token[];
+  /** Shared inherited prop-name lists, deduplicated across components. */
+  propSets: Record<string, string[]>;
+  /**
+   * Every value the component files export, components or not (`Icons`,
+   * `buttonVariants`), so the linter tells an invented name from a real export.
+   */
+  exports: string[];
+  /** Non-fatal problems found while extracting (unparseable files, unmatched docs). */
+  warnings: string[];
+  /**
+   * The component files extraction read, relative to the root: a name one of them exports
+   * that is not a component was seen, while a file outside them was never looked at.
+   */
+  sources?: string[];
+  stats: {
+    files: {
+      components: number;
+      tokens: number;
+      docs: number;
+    };
+    durationMs: number;
+    fromCache: boolean;
+  };
+}
+type Severity = 'error' | 'warning';
+interface TextEdit {
+  /** 0-based offsets into the checked source, end exclusive. */
+  range: [number, number];
+  text: string;
+}
+interface Diagnostic {
+  ruleId: string;
+  severity: Severity;
+  message: string;
+  /** 1-based. */
+  line: number;
+  /** 1-based. */
+  column: number;
+  endLine: number;
+  endColumn: number;
+  /** The offending source text. */
+  source: string;
+  /** What to write instead, e.g. `bg-destructive` or `<Button>`. */
+  suggestion?: string;
+  /** Edits that apply the suggestion, when it can be done mechanically. */
+  fix?: TextEdit[];
+}
+interface CheckResult {
+  file: string;
+  diagnostics: Diagnostic[];
+  errorCount: number;
+  warningCount: number;
+  /** With a baseline: findings it accepted, left out of `diagnostics` and the counts. */
+  baselined?: number;
+  /**
+   * Components imported from design-system modules the model does not include
+   * (extraction is incomplete), which the rules could not check.
+   */
+  unchecked?: {
+    names: string[];
+    modules: string[];
+  };
+  /**
+   * Why the file was not checked: it renders outside the browser's CSS (an
+   * Open Graph image through next/og, an email through React Email), where
+   * design tokens and classes do not apply.
+   */
+  skipped?: string;
+}
+//#endregion
+//#region src/libraries/index.d.ts
+/** The ids of the libraries onsystem can read, for the config's `libraries` list. */
+declare const LIBRARY_IDS: readonly ["mui"];
+type LibraryId = (typeof LIBRARY_IDS)[number];
+/** A library an app depends on, and where it is installed. */
+interface LibrarySource {
+  package: string;
+  /** The installed package's folder, absolute; undefined when it is a dependency but not installed. */
+  dir?: string | undefined;
+  /** The installed version. */
+  version?: string | undefined;
+}
+//#endregion
+//#region src/config.d.ts
+declare const RULE_IDS: readonly ["no-hardcoded-color", "no-hardcoded-spacing", "no-hardcoded-radius", "prefer-design-system-component", "no-unknown-component", "no-unknown-prop", "no-unknown-variant", "icon-button-accessible-name"];
+type RuleId = (typeof RULE_IDS)[number];
+declare const severitySchema: z.ZodEnum<{
+  error: "error";
+  off: "off";
+  warn: "warn";
+}>;
+type RuleSeverity = z.infer<typeof severitySchema>;
+declare const ruleOptionsSchema: z.ZodObject<{
+  allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type RuleOptions = z.infer<typeof ruleOptionsSchema>;
+declare const configSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  components: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>]>>;
+  docs: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  tsconfig: z.ZodOptional<z.ZodString>;
+  importPath: z.ZodOptional<z.ZodString>;
+  elements: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  libraries: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodArray<z.ZodEnum<{
+    mui: "mui";
+  }>>]>>;
+  includeDesignSystem: z.ZodOptional<z.ZodBoolean>;
+  rules: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+    "no-hardcoded-color": "no-hardcoded-color";
+    "no-hardcoded-spacing": "no-hardcoded-spacing";
+    "no-hardcoded-radius": "no-hardcoded-radius";
+    "prefer-design-system-component": "prefer-design-system-component";
+    "no-unknown-component": "no-unknown-component";
+    "no-unknown-prop": "no-unknown-prop";
+    "no-unknown-variant": "no-unknown-variant";
+    "icon-button-accessible-name": "icon-button-accessible-name";
+  }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
+    error: "error";
+    off: "off";
+    warn: "warn";
+  }>, z.ZodTuple<[z.ZodEnum<{
+    error: "error";
+    off: "off";
+    warn: "warn";
+  }>], null>, z.ZodTuple<[z.ZodEnum<{
+    error: "error";
+    off: "off";
+    warn: "warn";
+  }>, z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>], null>]>>>;
+  overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    files: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    rules: z.ZodRecord<z.ZodEnum<{
+      "no-hardcoded-color": "no-hardcoded-color";
+      "no-hardcoded-spacing": "no-hardcoded-spacing";
+      "no-hardcoded-radius": "no-hardcoded-radius";
+      "prefer-design-system-component": "prefer-design-system-component";
+      "no-unknown-component": "no-unknown-component";
+      "no-unknown-prop": "no-unknown-prop";
+      "no-unknown-variant": "no-unknown-variant";
+      "icon-button-accessible-name": "icon-button-accessible-name";
+    }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
+      error: "error";
+      off: "off";
+      warn: "warn";
+    }>, z.ZodTuple<[z.ZodEnum<{
+      error: "error";
+      off: "off";
+      warn: "warn";
+    }>], null>, z.ZodTuple<[z.ZodEnum<{
+      error: "error";
+      off: "off";
+      warn: "warn";
+    }>, z.ZodObject<{
+      allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], null>]>>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type Config = z.input<typeof configSchema>;
+/** Identity helper for typed `onsystem.config.ts` files. */
+declare function defineConfig(config: Config): Config;
+interface TokenSourceConfig {
+  path: string;
+  prefix?: string | undefined;
+  /** Read only when no other source finds a token file (zero config's `DESIGN.md`). */
+  fallback?: boolean | undefined;
+}
+interface ResolvedRule {
+  severity: RuleSeverity;
+  options: RuleOptions;
+}
+/** Rule settings for the files that match `files` (root-relative globs). */
+interface ResolvedOverride {
+  files: string[];
+  rules: Partial<Record<RuleId, ResolvedRule>>;
+}
+interface ResolvedConfig {
+  root: string;
+  configFile?: string | undefined;
+  components: string[];
+  /** What `check`, the ESLint plugin and the hook leave out of the project's own files. */
+  exclude: string[];
+  /**
+   * What finding the design system's own files (components, tokens, docs) leaves out, when it
+   * is not `exclude`: a design-system package's own list, rebased onto the package. An app that
+   * takes on the package's config leaves out the default `exclude` patterns as well.
+   */
+  designSystemExclude?: string[] | undefined;
+  tokens: TokenSourceConfig[];
+  docs: string[];
+  tsconfig?: string | undefined;
+  importPath?: string | undefined;
+  /** Import specifiers for component files, from the `exports` of the package that holds them. */
+  imports?: ImportMapping[] | undefined;
+  /** How the design system was found when the config does not say (`components.json`, a workspace package). */
+  detected?: string | undefined;
+  /**
+   * Several design systems found at once, the most imported first: its components win
+   * where two share a name, and are the ones suggested for native elements.
+   */
+  designSystems?: DesignSystemSource[] | undefined;
+  /** A Tailwind v3 config, which maps color classes to custom properties (`primary` → `hsl(var(--primary))`). */
+  tailwindConfig?: string | undefined;
+  /**
+   * Published component libraries the project depends on, read from their type declarations
+   * (MUI), whatever the config says about `components`: their components are checked where
+   * the code imports them, and the project's own components win a shared name.
+   */
+  libraries?: LibrarySource[] | undefined;
+  /**
+   * The config's `libraries`: the ids of the libraries to read, or false for none. Undefined
+   * reads every library onsystem supports.
+   */
+  libraryIds?: false | LibraryId[] | undefined;
+  /** Libraries the project depends on that `libraries` leaves out, so they are not read. */
+  librariesOff?: LibrarySource[] | undefined;
+  elements: Record<string, string>;
+  /** `check` lints the component files themselves, which it skips by default. */
+  includeDesignSystem: boolean;
+  rules: Record<RuleId, ResolvedRule>;
+  /** Per-file rule settings, applied in order over `rules`. */
+  overrides?: ResolvedOverride[] | undefined;
+  /**
+   * The folder `overrides` globs are relative to, when it is not the root: the workspace
+   * root, for a project that takes its settings from a config there.
+   */
+  base?: string | undefined;
+  /**
+   * The design-system package whose config this is: a dependency whose package.json declares it
+   * (`"onsystem": "./onsystem.config.json"`), taken on by a project with no config of its own.
+   * Its paths are rebased from the package; its `tsconfig`, `overrides` and
+   * `includeDesignSystem` stay with it.
+   */
+  designSystemPackage?: DesignSystemPackage | undefined;
+  /** `components` comes from the config file or `--components`, not from detection or the defaults. */
+  configured?: boolean | undefined;
+  /**
+   * What to tell the user about the config's name: a config file found under its name from
+   * before the rename to onsystem. The CLI prints these once per run, the server logs them once.
+   */
+  deprecations?: string[] | undefined;
+  /**
+   * What to tell the user about a design-system package's config: one installed from a
+   * registry whose declaration cannot be read, which was skipped, or paths in one that point
+   * outside it, which were ignored. The CLI prints these once per run, the server logs them
+   * once, and the ESLint plugin writes them once to stderr.
+   */
+  warnings?: string[] | undefined;
+}
+interface LoadConfigOptions {
+  /** Where to look for a config file when `root` and `config` are not given. */
+  cwd?: string;
+  /** Project root. Defaults to the config file's directory, then `cwd`. */
+  root?: string | undefined;
+  /** Explicit config file path. */
+  config?: string | undefined;
+  /**
+   * The folder the config file's paths and globs are written relative to, when it is not
+   * the root: a workspace root whose config a project in it takes on.
+   */
+  base?: string | undefined;
+  /** CLI overrides; replace the config file's values when set. */
+  components?: string[] | undefined;
+  tokens?: string[] | undefined;
+  docs?: string[] | undefined;
+  includeDesignSystem?: boolean | undefined;
+  /**
+   * Read a JSON config only: a JavaScript or TypeScript config is an error rather than run.
+   * For a project the MCP server found from the path a tool call names, which a prompt can
+   * choose, unlike the folder the server was started in.
+   */
+  jsonConfigOnly?: boolean | undefined;
+}
+declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedConfig>;
+/** JSON Schema for editor completion in `onsystem.config.json`. */
+declare function configJsonSchema(): Record<string, unknown>;
+//#endregion
+export { TOKEN_CATEGORIES as C, VariantInfo as D, TokenCategory as E, ImportMapping as O, SourceLocation as S, Token as T, DocSection as _, ResolvedRule as a, PropInfo as b, configJsonSchema as c, CheckResult as d, ComponentDocs as f, Diagnostic as g, DesignSystemModel as h, ResolvedConfig as i, defineConfig as l, CompoundVariantInfo as m, LoadConfigOptions as n, RuleId as o, ComponentInfo as p, RULE_IDS as r, RuleOptions as s, Config as t, loadConfig as u, ExampleInfo as v, TextEdit as w, Severity as x, InheritedProps as y };