@scolladon/tsgit 2.0.1 → 3.1.0

package/dist/types/chunks/write-tree-DRI-LzSr.d.ts

@@ -1,196 +0,0 @@
-import { b as Context, O as ObjectId, c as FilePath, j as RefName, g as HookName } from './context-CCL0_F8R.js';
-import { d as CatFileBatchOptions, C as CatFileBatchEntry, e as CreateCommitInput, D as DiffTreesInput, f as DiffTreesOptions, T as TreeDiff, s as ReadObjectOptions, B as Blob, G as GitObject, a as Tree, t as ResolveRefOptions, F as FileMode, U as UpdateRefOptions, W as WalkCommitsOptions, E as Commit, v as WalkSubmodulesOptions, S as SubmoduleEntry, x as WalkTreeOptions, w as WalkTreeEntry, z as WalkWorkingTreeOptions, y as WalkWorkingTreeEntry, H as TreeEntry } from './reflog-entry-CSzjnZd4.js';
-import { G as GitIndex, a as IndexEntryFlags, I as IndexEntry } from './index-entry-UD4dvtKh.js';
-
-declare function catFileBatch(ctx: Context, ids: AsyncIterable<ObjectId> | Iterable<ObjectId>, options?: CatFileBatchOptions): AsyncIterable<CatFileBatchEntry>;
-
-declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
-
-declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
-
-interface HashBlobOptions {
-    /** Persist the loose object under `.git/objects/<2>/<38>`. Default `false`. */
-    readonly write?: boolean;
-}
-declare const hashBlob: (ctx: Context, content: Uint8Array, opts?: HashBlobOptions) => Promise<ObjectId>;
-
-interface IsIgnoredQuery {
-    readonly path: FilePath;
-    /** Match directory rules (`build/`). Defaults to `false`. */
-    readonly isDirectory?: boolean;
-}
-interface IsIgnoredMatchSource {
-    readonly kind: 'global' | 'info' | 'gitignore';
-    /** POSIX-relative directory whose file carried the rule. `''` for global / info / repo-root gitignore. */
-    readonly basedir: FilePath | '';
-    /** 1-based line number of the matching rule inside its file. */
-    readonly line: number;
-    /** Raw pattern text (e.g. `*.log`, `!keep.log`, `build/`). */
-    readonly pattern: string;
-}
-interface IsIgnoredMatch {
-    readonly path: FilePath;
-    readonly ignored: boolean;
-    /** Set only when `ignored === true`. */
-    readonly source?: IsIgnoredMatchSource;
-}
-declare const isIgnored: (ctx: Context, queries: ReadonlyArray<IsIgnoredQuery>) => Promise<ReadonlyArray<IsIgnoredMatch>>;
-
-interface MergeBaseOptions {
-    readonly all?: boolean;
-    readonly octopus?: boolean;
-}
-/**
- * Compute merge bases — the best common ancestors of the given commits.
- *
- * `commits[0]` is `one`, the rest are the others. Returns the lexicographically
- * smallest single base by default; the full reduced set with `{ all: true }`;
- * the octopus fold with `{ octopus: true }`. Unrelated histories yield `[]`.
- */
-declare const mergeBase: (ctx: Context, commits: readonly ObjectId[], options?: MergeBaseOptions) => Promise<readonly ObjectId[]>;
-
-/**
- * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
- * No I/O. No port access. Primitive step 3.
- */
-
-/**
- * Repository working-tree root. Returns the workDir from the current context;
- * facade-tier code is responsible for discovery / realpath pinning
- * at construction time. Primitives consume the already-resolved path.
- */
-declare const getRepoRoot: (ctx: Context) => FilePath;
-declare const sparseCheckoutPath: (gitDir: string) => string;
-
-declare function readBlob(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<Blob>;
-
-declare function readIndex(ctx: Context): Promise<GitIndex>;
-
-declare function readObject(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<GitObject>;
-
-declare function readTree(ctx: Context, ref: RefName | ObjectId): Promise<Tree>;
-
-/**
- * The single reflog *writer*. Self-contained: reads config, applies the gate,
- * resolves identity, sanitises the message, and appends one entry. Callers
- * supply only a human-readable message.
- */
-
-/**
- * Append a reflog entry for `ref` if logging applies. A no-op when the gate is
- * closed for `ref` — once a reflog file exists every update appends to it,
- * otherwise the `core.logAllRefUpdates` prefix rule decides.
- */
-declare function recordRefUpdate(ctx: Context, ref: RefName, oldId: ObjectId, newId: ObjectId, message: string): Promise<void>;
-
-declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
-
-/** Optional arguments and stdin a caller threads into a hook invocation. */
-interface HookInput {
-    readonly args?: ReadonlyArray<string>;
-    readonly stdin?: string;
-}
-/**
- * Run a named git hook through `ctx.hooks`. A no-op when no `HookRunner` is
- * wired (browser, or opted out), when the hook file is absent / not executable
- * (`skipped`), or when the hook exits 0. Throws `HOOK_FAILED` on a non-zero
- * exit.
- */
-declare const runHook: (ctx: Context, name: HookName, input?: HookInput) => Promise<void>;
-
-/**
- * Flip flags (`assumeValid`, `skipWorktree`, `intentToAdd`) on an existing
- * index entry without rehashing. Used by `stash pop`, `mv`, and other
- * porcelain that need to restore flag state after a tree-level operation.
- *
- * The on-disk version is auto-promoted to v3 by `serializeIndex` whenever
- * an extended flag flips true — nothing to manage at the primitive layer
- * (ADR-164).
- */
-
-interface SetEntryFlagsOptions {
-    readonly breakStaleLockMs?: number;
-}
-declare const setEntryFlags: (ctx: Context, path: FilePath, flags: Partial<IndexEntryFlags>, opts?: SetEntryFlagsOptions) => Promise<IndexEntry>;
-
-type StageEntrySource = {
-    readonly content: Uint8Array;
-    readonly mode?: FileMode;
-} | {
-    readonly id: ObjectId;
-    readonly mode: FileMode;
-};
-interface StageEntryOptions {
-    readonly breakStaleLockMs?: number;
-    /** Flags overlay on top of `STAGE0_FLAGS`. Use to seed `intentToAdd` etc. */
-    readonly flags?: Partial<IndexEntryFlags>;
-}
-declare const stageEntry: (ctx: Context, path: FilePath, source: StageEntrySource, opts?: StageEntryOptions) => Promise<IndexEntry>;
-
-interface UnstageEntryOptions {
-    readonly breakStaleLockMs?: number;
-}
-declare const unstageEntry: (ctx: Context, path: FilePath, opts?: UnstageEntryOptions) => Promise<{
-    readonly removed: boolean;
-}>;
-
-declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options: UpdateRefOptions): Promise<void>;
-
-declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
-
-/**
- * Yield every gitlink reachable in `ref`'s tree, joined with its `.gitmodules`
- * metadata. With `recursive: true`, descend into each nested submodule whose
- * absorbed gitdir (`${gitDir}/modules/<name>`) is locally available; nested
- * yields carry `depth >= 1` and a `parent` path. Uninitialised / missing /
- * cyclic nested submodules contribute their own entry but no children — the
- * absence of further yields is the signal, matching `git submodule status
- * --recursive`.
- */
-declare function walkSubmodules(ctx: Context, options?: WalkSubmodulesOptions): AsyncIterable<SubmoduleEntry>;
-
-declare function walkTree(ctx: Context, treeIdOrObject: ObjectId | Tree, options?: WalkTreeOptions): AsyncIterable<WalkTreeEntry>;
-
-/**
- * Depth-first walk of the working tree starting at `ctx.layout.workDir`.
- *
- * Yields leaf entries (files and symlinks) as `{ path, stat }`. Directories
- * are descended into, not yielded. `.git` at any level is skipped
- * (case-insensitive, NTFS-trimmed). Embedded repositories (directories
- * containing a `.git` child) are skipped entirely — yields nothing under
- * them. Symlinks are surfaced via `lstat` (no follow); a symlink to a
- * directory is yielded as a leaf, not descended into.
- *
- * The host repository's own `.git` is NOT treated as an embedded-repo
- * marker — at the workDir root we only skip the `.git` entry itself, not
- * the workDir.
- */
-declare function walkWorkingTree(ctx: Context, options?: WalkWorkingTreeOptions): AsyncIterable<WalkWorkingTreeEntry>;
-
-declare function writeObject(ctx: Context, object: GitObject): Promise<ObjectId>;
-
-/**
- * Symbolic-ref writer. Produces `ref: <target>\n` files (HEAD and friends).
- * Used by `init`/`clone`/branch-rename to set the initial HEAD pointer.
- *
- * @writes
- *   surface: symbolicRef
- *   kind:    byte-identical
- *   format:  git-symbolic-ref
- */
-
-/**
- * Write a symbolic ref atomically. Used for HEAD updates that point at a
- * branch, branch renames affecting the current HEAD, and `clone`/`init`
- * to set the initial HEAD.
- *
- * Single-level only in v1: target MUST be a direct ref name (no chained
- * symrefs). Validation runs through `validateRefName` for both `name` and
- * `target` — invalid inputs throw INVALID_REF before any I/O.
- */
-declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
-
-declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
-
-export { sparseCheckoutPath as E, createCommit as a, readIndex as b, catFileBatch as c, diffTrees as d, readObject as e, readTree as f, getRepoRoot as g, hashBlob as h, isIgnored as i, recordRefUpdate as j, resolveRef as k, runHook as l, mergeBase as m, stageEntry as n, updateRef as o, walkSubmodules as p, walkTree as q, readBlob as r, setEntryFlags as s, walkWorkingTree as t, unstageEntry as u, writeObject as v, walkCommits as w, writeSymbolicRef as x, writeTree as y };
-export type { IsIgnoredMatchSource as A, IsIgnoredQuery as B, StageEntryOptions as C, StageEntrySource as D, HashBlobOptions as H, IsIgnoredMatch as I, SetEntryFlagsOptions as S, UnstageEntryOptions as U, HookInput as z };