@zipbul/gildash 0.26.0 → 0.27.0

package/dist/src/extractor/types.d.ts

@@ -319,7 +319,26 @@ export interface CodeRelation {
     metaJson?: string;
     /** Parsed metadata object derived from `metaJson`. */
     meta?: Record<string, unknown>;
-    /** Raw import specifier (e.g. `'lodash'`, `'./missing'`). Present for unresolved/external imports. */
+    /**
+     * Verbatim module specifier text as written in the source — `'./foo'`,
+     * `'@zipbul/core'`, `'lodash'`, etc. Always present on any
+     * module-source-bearing relation: `'imports'`, `'re-exports'`,
+     * `'type-references'` (any typed import or typed re-export — including
+     * bare re-exports cross-referenced through an existing typed import),
+     * dynamic `import(...)`, and `require(...)`. Preserved regardless of
+     * whether `dstFilePath` was successfully resolved, so consumers can
+     * reconstruct the original import form without reverse-engineering
+     * tsconfig paths, package `exports` maps, or relative-path normalization.
+     *
+     * For bare re-exports (`export { x };`) where `x` was previously imported,
+     * the relation cross-references the originating import statement and
+     * `specifier` carries that import's source text. Bare re-exports that
+     * cannot be cross-referenced are *not emitted* as relations at all
+     * (rather than emitted with `specifier` absent).
+     *
+     * Absent only on relations with no associated module source — `'calls'`,
+     * `'extends'`, `'implements'`.
+     */
     specifier?: string;
 }
 export type AnnotationSource = 'jsdoc' | 'line' | 'block';

package/dist/src/index.d.ts

@@ -30,3 +30,6 @@ export type { SourcePosition, SourceSpan } from './parser/types';
 export type { Program, Node } from 'oxc-parser';
 export { Visitor, visitorKeys } from 'oxc-parser';
 export type { VisitorObject } from 'oxc-parser';
+export { walk, parseAndWalk, ScopeTracker } from 'oxc-walker';
+export type { WalkerEnter, WalkerLeave, WalkerCallbackContext, WalkerThisContextEnter, WalkerThisContextLeave, WalkOptions, ScopeTrackerNode, ScopeTrackerOptions, } from 'oxc-walker';
+export { isArrowFunctionExpression, isAssignmentExpression, isCallExpression, isFunctionDeclaration, isFunctionExpression, isFunctionNode, isIdentifier, isMemberExpression, isTSQualifiedName, isVariableDeclaration, } from './parser/ast-utils';

package/dist/src/parser/ast-utils.d.ts

@@ -1,6 +1,76 @@
+import type { Node } from 'oxc-parser';
 import type { QualifiedName } from '../extractor/types';
 export declare function getNodeHeader(node: Record<string, unknown>, parent?: Record<string, unknown> | null): string;
-export declare function isFunctionNode(node: Record<string, unknown>): boolean;
+/**
+ * Type predicate for the union of FunctionDeclaration / FunctionExpression /
+ * ArrowFunctionExpression discriminators.
+ *
+ * Note: `FunctionDeclaration` and `FunctionExpression` both narrow to the
+ * `Function` interface in @oxc-project/types — that interface's `type` field
+ * is also satisfied by `TSDeclareFunction` and `TSEmptyBodyFunctionExpression`,
+ * but those discriminators return `false` here at runtime. Callers reading
+ * `.params` / `.body` should be aware that `body` may be `null` only on the
+ * declare/empty-body variants (excluded by this predicate).
+ */
+export declare function isFunctionNode(node: Node): node is Extract<Node, {
+    type: 'FunctionDeclaration' | 'FunctionExpression' | 'ArrowFunctionExpression';
+}>;
+export declare function isArrowFunctionExpression(node: Node): node is Extract<Node, {
+    type: 'ArrowFunctionExpression';
+}>;
+export declare function isAssignmentExpression(node: Node): node is Extract<Node, {
+    type: 'AssignmentExpression';
+}>;
+export declare function isCallExpression(node: Node): node is Extract<Node, {
+    type: 'CallExpression';
+}>;
+/**
+ * Note: discriminator `"FunctionDeclaration"` narrows to the `Function`
+ * interface, which structurally also accepts `type: 'TSDeclareFunction'` and
+ * `type: 'TSEmptyBodyFunctionExpression'` — but those literals fail this
+ * runtime check. Narrowed result has `.params` (always) and `.body` (typed
+ * `FunctionBody | null`; non-null for FunctionDeclaration / FunctionExpression).
+ */
+export declare function isFunctionDeclaration(node: Node): node is Extract<Node, {
+    type: 'FunctionDeclaration';
+}>;
+/** See `isFunctionDeclaration` for shared `Function` interface notes. */
+export declare function isFunctionExpression(node: Node): node is Extract<Node, {
+    type: 'FunctionExpression';
+}>;
+/**
+ * Note: discriminator `"Identifier"` is shared by 6 interfaces in
+ * @oxc-project/types — IdentifierName, IdentifierReference, BindingIdentifier,
+ * LabelIdentifier, TSThisParameter, TSIndexSignatureName. All 6 expose `.name`
+ * (string; literal `"this"` for TSThisParameter). The narrowed result is the
+ * union of all 6; callers needing finer distinction must check additional
+ * fields (e.g. TSThisParameter has `decorators: []` and `optional: false`).
+ */
+export declare function isIdentifier(node: Node): node is Extract<Node, {
+    type: 'Identifier';
+}>;
+/**
+ * Note: discriminator `"MemberExpression"` is shared by 3 interfaces —
+ * ComputedMemberExpression, StaticMemberExpression, PrivateFieldExpression.
+ * All 3 expose `.object` and a property-side field (`.property` /
+ * `.field`). Callers needing finer distinction should check `.computed`
+ * (Computed only) or the property-side field shape.
+ */
+export declare function isMemberExpression(node: Node): node is Extract<Node, {
+    type: 'MemberExpression';
+}>;
+/**
+ * Note: discriminator `"TSQualifiedName"` is shared by 2 interfaces —
+ * TSQualifiedName and TSImportTypeQualifiedName. Both expose `.left` and
+ * `.right`, but `.left` shape differs (TSQualifiedName: TSQualifiedName |
+ * IdentifierName; TSImportTypeQualifiedName: TSImportTypeQualifier).
+ */
+export declare function isTSQualifiedName(node: Node): node is Extract<Node, {
+    type: 'TSQualifiedName';
+}>;
+export declare function isVariableDeclaration(node: Node): node is Extract<Node, {
+    type: 'VariableDeclaration';
+}>;
 export declare function getNodeName(node: unknown): string | null;
 export declare function getStringLiteralValue(node: unknown): string | null;
 export declare function getQualifiedName(expr: unknown): QualifiedName | null;

package/dist/src/parser/index.d.ts

@@ -1,6 +1,6 @@
 export { parseSource } from './parse-source';
 export { ParseCache } from './parse-cache';
 export { buildLineOffsets, getLineColumn, } from './source-position';
-export { getNodeHeader, isFunctionNode, getNodeName, getStringLiteralValue, getQualifiedName, } from './ast-utils';
+export { getNodeHeader, isArrowFunctionExpression, isAssignmentExpression, isCallExpression, isFunctionDeclaration, isFunctionExpression, isFunctionNode, isIdentifier, isMemberExpression, isTSQualifiedName, isVariableDeclaration, getNodeName, getStringLiteralValue, getQualifiedName, } from './ast-utils';
 export { parseJsDoc } from './jsdoc-parser';
 export type { ParsedFile, SourcePosition, SourceSpan } from './types';

package/dist/src/search/relation-search.d.ts

@@ -8,7 +8,14 @@ export interface StoredCodeRelation extends Omit<CodeRelation, 'specifier'> {
     dstProject: string | null;
     /** Whether this relation targets an external (bare specifier) package. */
     isExternal: boolean;
-    /** The raw import specifier string (e.g. `'lodash'`, `'./missing'`). `null` when the import was resolved to a file. */
+    /**
+     * Verbatim module specifier text as written in the source — `'./foo'`,
+     * `'@zipbul/core'`, `'lodash'`, etc. Preserved regardless of whether
+     * the import was successfully resolved to a file. `null` only on
+     * relations with no associated module source (`'calls'`, `'extends'`,
+     * `'implements'`). See {@link CodeRelation.specifier} for the full
+     * contract.
+     */
     specifier: string | null;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/gildash",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "TypeScript code indexing and dependency graph engine for Bun",
   "license": "MIT",
   "repository": {