obsidian-dev-utils 76.0.0 → 77.0.0

package/dist/lib/esm/script-utils/linters/markdownlint.mjs

@@ -41,8 +41,8 @@ import {
   getRootFolder,
   resolvePathFromRootSafe
 } from "../root.mjs";
-async function lint(params) {
-  const { paths, shouldFix = false } = params ?? {};
+async function lint(options) {
+  const { paths, shouldFix = false } = options ?? {};
   const configFiles = [
     ObsidianPluginRepoPaths.MarkdownlintCli2ConfigJsonc,
     ObsidianPluginRepoPaths.MarkdownlintCli2ConfigYaml,
@@ -101,4 +101,4 @@ async function lint(params) {
 export {
   lint
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/over-exposure.d.mts

@@ -0,0 +1,204 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * Over-exposure analyzer.
+ *
+ * Finds declarations exposed more broadly than their references require, so the exposure can be
+ * tightened:
+ *
+ * - `export`ed symbols referenced only within their own file — the `export` can be dropped.
+ * - `public` class members referenced only inside their own class — they can be `private`.
+ * - `public` class members referenced only inside their own class and its subclasses — they can be
+ *   `protected`.
+ * - `protected` class members referenced only inside their own class — they can be `private`.
+ *
+ * The analysis is whole-program and type-aware: it uses the TypeScript language service's
+ * find-all-references to locate every use of each declaration, then classifies the tightest
+ * exposure that still covers all references. Members invoked by the framework via registration
+ * rather than by visible references (Obsidian lifecycle hooks, settings-tab `display`, etc.) are
+ * excluded via {@link LIFECYCLE_ALLOWLIST}, as are `override` and `static` members whose exposure is
+ * constrained by a base declaration.
+ *
+ * A member referenced only from test files is reported with {@link OverExposureFinding.isForcedByTestOnly}
+ * set, surfacing members widened purely for testability — the canonical case for extracting logic
+ * into an independently testable component instead.
+ */
+import type { CompilerOptions, LanguageService, LanguageServiceHost } from 'typescript';
+/**
+ * Parameters for {@link analyzeOverExposure}.
+ */
+export interface AnalyzeOverExposureParams {
+    /** The language service to query for references and types. */
+    readonly languageService: LanguageService;
+    /**
+     * Optional callback invoked once per analyzed source file, before that file is processed. The
+     * whole-program reference analysis is slow, so this lets callers report live progress instead of
+     * appearing to hang.
+     */
+    onProgress?(this: void, progress: OverExposureProgress): void;
+    /**
+     * Absolute (canonical) path of the project's `src` folder. Only declarations in non-test files
+     * under this folder are analyzed; declarations elsewhere (test files, dependencies) are ignored
+     * but still counted as reference sites.
+     */
+    readonly srcFolder: string;
+}
+/**
+ * Parameters for {@link createLanguageServiceHost}.
+ */
+export interface CreateLanguageServiceHostParams {
+    /** The compiler options. */
+    readonly compilerOptions: CompilerOptions;
+    /** The files to include in the program. */
+    readonly fileNames: readonly string[];
+    /** The file-system operations used to read sources. */
+    readonly fileSystem: OverExposureFileSystem;
+}
+/**
+ * Parameters for {@link createProjectLanguageService}.
+ */
+export interface CreateProjectLanguageServiceParams {
+    /** Absolute path to the project's `tsconfig.json`. */
+    readonly tsConfigPath: string;
+}
+/**
+ * The exposure level a declaration currently has.
+ */
+export type CurrentExposure = 'export' | 'protected' | 'public';
+/**
+ * Parameters for {@link findOverExposure}.
+ */
+export interface FindOverExposureParams {
+    /**
+     * Optional callback invoked once per analyzed source file, for live progress reporting. Forwarded
+     * to {@link analyzeOverExposure}.
+     */
+    onProgress?(this: void, progress: OverExposureProgress): void;
+    /** Absolute path to the project root (the folder containing `tsconfig.json` and `src`). */
+    readonly projectFolder: string;
+}
+/**
+ * The subset of file-system operations the language-service host needs. Injecting this (rather than
+ * always using `typescript`'s `sys`) lets tests drive the analyzer against in-memory sources with no
+ * real file-system access.
+ */
+export interface OverExposureFileSystem {
+    /**
+     * @param path - Directory path.
+     * @returns `true` when the directory exists.
+     */
+    directoryExists(this: void, path: string): boolean;
+    /**
+     * @param path - File path.
+     * @returns `true` when the file exists.
+     */
+    fileExists(this: void, path: string): boolean;
+    /**
+     * @returns The current working directory.
+     */
+    getCurrentDirectory(this: void): string;
+    /**
+     * @param path - Directory path.
+     * @returns The immediate subdirectory names.
+     */
+    getDirectories(this: void, path: string): string[];
+    /**
+     * @param path - Root directory.
+     * @param extensions - Extensions to include.
+     * @param exclude - Patterns to exclude.
+     * @param include - Patterns to include.
+     * @param depth - Maximum recursion depth.
+     * @returns The matching file paths.
+     */
+    readDirectory(this: void, path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
+    /**
+     * @param path - File path.
+     * @returns The file contents, or `undefined` when absent.
+     */
+    readFile(this: void, path: string): string | undefined;
+}
+/**
+ * A single over-exposed declaration.
+ */
+export interface OverExposureFinding {
+    /** 1-based column of the declaration's name. */
+    readonly column: number;
+    /** The current exposure level. */
+    readonly currentExposure: CurrentExposure;
+    /** Absolute path of the file declaring the symbol. */
+    readonly filePath: string;
+    /** `true` when the declaration has no references at all (besides itself). */
+    readonly hasNoReferences: boolean;
+    /**
+     * `true` when the declaration would qualify for a tighter exposure if not for references coming
+     * exclusively from test files — i.e. it is exposed purely for testability.
+     */
+    readonly isForcedByTestOnly: boolean;
+    /** `true` for a class member, `false` for a top-level export. */
+    readonly isMember: boolean;
+    /** 1-based line of the declaration's name. */
+    readonly line: number;
+    /** The declared name. */
+    readonly name: string;
+    /** The exposure the declaration could be tightened to. */
+    readonly suggestedExposure: SuggestedExposure;
+}
+/**
+ * Progress reported while analyzing a project, one event per analyzed source file.
+ */
+export interface OverExposureProgress {
+    /** Number of source files fully analyzed before the current one (0-based). */
+    readonly analyzedFileCount: number;
+    /** Absolute (canonical) path of the source file about to be analyzed. */
+    readonly currentFilePath: string;
+    /** Total number of source files that will be analyzed. */
+    readonly totalFileCount: number;
+}
+/**
+ * The (tighter) exposure level a declaration could be reduced to.
+ */
+export type SuggestedExposure = 'file-local' | 'private' | 'protected';
+/**
+ * Lifecycle and framework members invoked by Obsidian or a base class via registration rather than
+ * by references the language service can see. Tightening these would break the framework contract,
+ * so they are never reported.
+ */
+export declare const LIFECYCLE_ALLOWLIST: ReadonlySet<string>;
+/**
+ * Analyzes a project (already loaded into a language service) for over-exposed declarations.
+ *
+ * @param params - The {@link AnalyzeOverExposureParams}.
+ * @returns The over-exposed declarations, in discovery order.
+ */
+export declare function analyzeOverExposure(params: AnalyzeOverExposureParams): OverExposureFinding[];
+/**
+ * Builds a {@link LanguageServiceHost} backed by an explicit file list and file system.
+ *
+ * @param params - The {@link CreateLanguageServiceHostParams}.
+ * @returns The language-service host.
+ */
+export declare function createLanguageServiceHost(params: CreateLanguageServiceHostParams): LanguageServiceHost;
+/**
+ * Builds a language service over every file in a project's `tsconfig.json`.
+ *
+ * @param params - The {@link CreateProjectLanguageServiceParams}.
+ * @returns A language service ready for {@link analyzeOverExposure}.
+ */
+export declare function createProjectLanguageService(params: CreateProjectLanguageServiceParams): LanguageService;
+/**
+ * Finds over-exposed declarations in a project on disk.
+ *
+ * @param params - The {@link FindOverExposureParams}.
+ * @returns The over-exposed declarations.
+ */
+export declare function findOverExposure(params: FindOverExposureParams): OverExposureFinding[];
+/**
+ * Formats over-exposure findings as a human-readable report. Findings are grouped by file and each
+ * line begins with a `path:line:column` location so terminals (e.g. VS Code) render it as a
+ * clickable link that jumps to the declaration.
+ *
+ * @param findings - The findings to format.
+ * @returns The report text. Empty-finding input yields a single "no findings" line.
+ */
+export declare function formatOverExposureFindings(findings: readonly OverExposureFinding[]): string;