@bridge-ds/core 0.13.0 → 0.15.0

package/dist/repo-source-github.d.ts

@@ -0,0 +1,43 @@
+import { GitHubClient } from './github-client';
+import { type RepoSource } from './repo-source';
+/** Where blob bodies are kept between sources (IndexedDB in the browser). Keyed by blob sha; may be async. */
+export interface BlobCache {
+    get(sha: string): string | undefined | Promise<string | undefined>;
+    set(sha: string, text: string): void | Promise<void>;
+}
+export interface GitHubSourceOptions {
+    /** Files larger than this are refused (status 413) instead of read. Default 1 MB. */
+    maxFileBytes?: number;
+    /** Body reads in flight at once. Default 4 (friendly to GitHub's secondary limits). */
+    concurrency?: number;
+    /**
+     * A cache that outlives the source, keyed by blob sha. Bodies of private repositories land in it, so the caller
+     * scopes it per repository and account and clears it on sign-out (plan 6.8).
+     */
+    blobCache?: BlobCache;
+    /**
+     * Hears what the source does: the tree once it is read (how many files the commit holds), then each body as it
+     * lands, saying whether it came from the blob cache (no request) or from GitHub.
+     */
+    onProgress?: (event: GitHubSourceProgress) => void;
+}
+/** What a GitHub source reports through `onProgress`. */
+export type GitHubSourceProgress = {
+    kind: 'tree';
+    files: number;
+} | {
+    kind: 'file';
+    path: string;
+    cached: boolean;
+};
+/** How bodies are read: the blobs API with the token, or the raw host without one. */
+export type GitHubSourceMode = 'api' | 'raw';
+export interface GitHubSource extends RepoSource {
+    /** Where body reads go: 'api' when the client has a token, 'raw' otherwise. */
+    readonly mode: GitHubSourceMode;
+}
+/**
+ * A source over `client`'s repository at commit `sha` (a full 40-character sha: a branch name would move under the
+ * cache). The first `list` or `text` call reads the tree; `text` of a path the tree does not list costs no request.
+ */
+export declare function gitHubSource(client: GitHubClient, sha: string, opts?: GitHubSourceOptions): GitHubSource;

package/dist/repo-source.d.ts

@@ -0,0 +1,38 @@
+/** Which repository and commit a source reads. `sha` pins every read; a local checkout may say "working-tree". */
+export interface RepoSourceRef {
+    owner: string;
+    repo: string;
+    sha: string;
+}
+export interface RepoSource {
+    ref: RepoSourceRef;
+    /**
+     * Repo-relative paths of every file under `prefix` (a directory, repo-relative, no trailing slash), at any depth,
+     * sorted. Omitted or empty: the whole repository. A missing directory lists nothing.
+     */
+    list(prefix?: string): Promise<string[]>;
+    /** Body of a repo-relative file as UTF-8 text, or null when the file does not exist. */
+    text(path: string): Promise<string | null>;
+}
+/** "./a//b/" -> "a/b". Paths in a RepoSource are repo-relative and use "/". */
+export declare function normalizeRepoPath(path: string): string;
+/** True when `path` is `prefix` itself or a file below it. An empty prefix holds everything. */
+export declare function isUnder(path: string, prefix: string | undefined): boolean;
+/** Parent directory of a repo-relative path ("" for a top-level file). */
+export declare const parentDir: (path: string) => string;
+/** Joins repo-relative segments, dropping empty ones and "." ("packages", "", "a.json" -> "packages/a.json"). */
+export declare const joinRepoPath: (...parts: (string | undefined)[]) => string;
+/**
+ * A source over files held in memory, keyed by repo-relative path. Used by tests, by snapshots and by any caller
+ * that already has the bodies (a browser cache).
+ */
+export declare function memorySource(files: Record<string, string>, ref?: Partial<RepoSourceRef>): RepoSource;
+/** How far a readRepoTexts call has gone: files settled (read, missing or skipped) out of the distinct paths asked. */
+export type ReadProgress = (done: number, total: number) => void;
+/**
+ * Reads many files with a few requests in flight (4 by default, like loadRepoFiles), keyed by the path asked for.
+ * A missing file maps to null. `onError` decides about a read that throws: return null to skip the file, or throw
+ * (the default) to fail the whole read. `onProgress` hears (0, total) first, then once per settled file: real counts,
+ * so a progress bar never runs ahead of the reads.
+ */
+export declare function readRepoTexts(source: RepoSource, paths: string[], concurrency?: number, onError?: (path: string, err: unknown) => null, onProgress?: ReadProgress): Promise<Map<string, string | null>>;

package/dist/{report-BeWNSjPk.js → report-DCPfvvoq.js}

@@ -1,4 +1,4 @@
-import { bn as hexToRgba, aW as comboKey } from "./prod-branch-6ftQWwdu.js";
+import { bn as hexToRgba, aX as comboKey } from "./prod-branch-BjXFIz74.js";
 import ts from "typescript";
 const AUDIT_SCHEMA_VERSION = 1;
 const FINDING_CATEGORIES = ["color", "spacing", "size", "radius", "border-width", "shadow", "duration", "easing", "z-index", "font-family", "font-size", "font-weight", "line-height"];
@@ -1907,4 +1907,4 @@ export {
   isRouterLink as y,
   isSafeFix as z
 };
-//# sourceMappingURL=report-BeWNSjPk.js.map
+//# sourceMappingURL=report-DCPfvvoq.js.map