test-inventory 0.4.1 → 0.5.0

package/dist/config.d.ts

@@ -0,0 +1,90 @@
+import type { ModuleReader, Span } from './model.ts';
+import { type ParsedFile } from './parse.ts';
+import type { ConfigRecord, Diagnostic, Framework, ProjectRecord } from './types.ts';
+import { Values } from './values.ts';
+/** A file a config is read from: the config itself, or a module it imports settings from, at `file`. */
+interface ConfigFrame {
+    parsed: ParsedFile;
+    values: Values;
+    relativeFilePath: string;
+    file: string;
+    readModule: ModuleReader;
+}
+/** Where an expression is written. */
+interface Site {
+    frame: ConfigFrame;
+    node: Span;
+}
+/** A setting the scan can't work out without running the config. `where` is null for a config it couldn't read at all. */
+export interface Unknown {
+    kind: 'unknown';
+    where: Site | null;
+}
+/**
+ * A config setting: a value, an object or a list of settings, or one the scan can't work out. An object's `rest` is a
+ * spread the scan can't work out, which may set any key not written after it.
+ */
+export type Setting = {
+    kind: 'value';
+    value: string | number | boolean | null | undefined;
+} | {
+    kind: 'regex';
+    source: string;
+    flags: string;
+} | ObjectSetting | {
+    kind: 'list';
+    items: Setting[];
+} | Unknown;
+export interface ObjectSetting {
+    kind: 'object';
+    keys: Map<string, Setting>;
+    rest: Unknown | null;
+}
+/** The source text of a setting the scan can't work out; null for one of a config it couldn't read at all. */
+export declare function unknownText(setting: Unknown): string | null;
+/** The setting under a path of keys, such as `['test', 'globals']`; null when the config doesn't set it. */
+export declare function settingAt(setting: Setting, keys: readonly string[]): Setting | null;
+/**
+ * Vite's `mergeConfig(base, over)`: objects merge key by key, lists are joined with a single setting taken as a list
+ * of one, and `null` or `undefined` keeps the other side.
+ */
+export declare function mergeDeep(base: Setting, over: Setting): Setting;
+/** The config a scanned file uses, read once however many files use it. */
+export interface ConfigFile {
+    /** The config's absolute path. */
+    file: string;
+    record: Omit<ConfigRecord, 'projects'>;
+    settings: Setting;
+}
+/** Finds and reads the configs of one scan, and collects what it can't work out in them as diagnostics. */
+export declare class Configs {
+    readonly diagnostics: Diagnostic[];
+    private readonly root;
+    private readonly framework;
+    private readonly readerFor;
+    private readonly inFolders;
+    private readonly files;
+    private readonly used;
+    private readonly reported;
+    private readonly version;
+    constructor(root: string, framework: Framework, readerFor: (fromFile: string) => ModuleReader, version: [number, number] | null);
+    /**
+     * The configs in a file's folder and the folders above it, up to the root, outermost first: in each folder, the one
+     * the runner started there would use.
+     */
+    around(file: string): ConfigFile[];
+    /** The config at a path, read once however many files or projects refer to it. */
+    at(file: string): ConfigFile;
+    /** A path from the root, with `/` separators; `.` for the root itself. */
+    relative(file: string): string;
+    /** Lists a config in the output, as one that scanned files use. */
+    use(config: ConfigFile): void;
+    /** The configs that scanned files use, sorted by path, with the projects `projectsOf` gives each. */
+    records(projectsOf: (config: ConfigFile) => ProjectRecord[] | null): ConfigRecord[];
+    /** Reports a setting the scan reads but can't work out, once; `key` names it, and `effect` says what the scan does. */
+    reportUnknown(setting: Unknown, key: string, effect: string): void;
+    /** The config the runner started in a folder would use; null when the folder has none. */
+    inFolder(folder: string): ConfigFile | null;
+    private read;
+}
+export {};