@zipbul/gildash 0.25.0 → 0.26.1

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

@@ -5,4 +5,4 @@ export { extractImports } from './imports-extractor';
 export { extractCalls } from './calls-extractor';
 export { extractHeritage } from './heritage-extractor';
 export { resolveImport, buildImportMap } from './extractor-utils';
-export type { ExtractedSymbol, SymbolKind, CodeRelation, Parameter, Modifier, Heritage, Decorator, ExpressionValue, ExpressionLiteral, ExpressionIdentifier, ExpressionMember, ExpressionCall, ExpressionNew, ExpressionObject, ExpressionObjectProperty, ExpressionArray, ExpressionSpread, ExpressionFunction, ExpressionTemplate, ExpressionUnresolvable, JsDocBlock, JsDocTag, ImportReference, QualifiedName, AnnotationSource, ExtractedAnnotation, } from './types';
+export type { ExtractedSymbol, SymbolKind, CodeRelation, Parameter, Modifier, Heritage, Decorator, ExpressionValue, ExpressionLiteral, ExpressionIdentifier, ExpressionMember, ExpressionCall, ExpressionNew, ExpressionObject, ExpressionObjectProperty, ExpressionArray, ExpressionSpread, ExpressionFunction, ExpressionTemplate, ExpressionUnresolvable, ExpressionObjectEntry, KeyExpression, SymbolKey, JsDocBlock, JsDocTag, ImportReference, QualifiedName, AnnotationSource, ExtractedAnnotation, } from './types';

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

@@ -9,10 +9,32 @@ import type { SourcePosition, SourceSpan } from '../parser/types';
  * The extractor does **not** resolve imports; use relation queries for that.
  */
 export type ExpressionValue = ExpressionLiteral | ExpressionIdentifier | ExpressionMember | ExpressionCall | ExpressionNew | ExpressionObject | ExpressionArray | ExpressionSpread | ExpressionFunction | ExpressionTemplate | ExpressionUnresolvable;
-export interface ExpressionLiteral {
-    kind: 'string' | 'number' | 'boolean' | 'null' | 'undefined';
-    value: string | number | boolean | null;
+export type ExpressionLiteral = {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'null';
+    value: null;
+} | {
+    kind: 'undefined';
+    value: null;
+}
+/** BigInt literal — value is the numeric portion as a string (e.g. `'42'` for `42n`). */
+ | {
+    kind: 'bigint';
+    value: string;
 }
+/** Regular-expression literal — value is the full source form (e.g. `'/foo/g'`). */
+ | {
+    kind: 'regex';
+    value: string;
+};
 export interface ExpressionIdentifier {
     kind: 'identifier';
     name: string;
@@ -45,14 +67,50 @@ export interface ExpressionNew {
 }
 export interface ExpressionObject {
     kind: 'object';
-    properties: ExpressionObjectProperty[];
+    /** Properties of the object literal, in source order. Each entry is either
+     *  a key/value property or a spread element (`...x`). */
+    properties: ExpressionObjectEntry[];
 }
+/** An entry inside an object literal — either a normal key/value property
+ *  or a spread (`...x`). The spread variant reuses {@link ExpressionSpread}
+ *  since the runtime shape is identical to spreads elsewhere. */
+export type ExpressionObjectEntry = ExpressionObjectProperty | ExpressionSpread;
 export interface ExpressionObjectProperty {
-    key: string;
+    kind: 'property';
+    /**
+     * Property key. Static identifier keys (`{ foo: 1 }`) and string-literal keys
+     * (`{ 'foo': 1 }`) are both encoded as `{ kind: 'string', value: 'foo' }`
+     * (their runtime semantics are identical). Numeric keys use `kind: 'number'`.
+     * Computed keys (`{ [expr]: 1 }`) carry the structured expression
+     * (with `importSource` resolution where applicable). Private (`#name`)
+     * is *not* valid in object literals and never appears here.
+     */
+    key: KeyExpression;
     value: ExpressionValue;
-    computed?: boolean;
+    /** True when written in shorthand form `{ x }` (equivalent to `{ x: x }`). */
     shorthand?: boolean;
 }
+/**
+ * Any `ExpressionValue` that can appear as a key — every variant except
+ * `spread` (which is not a valid key form anywhere). Used for object literal
+ * keys, computed class/interface member keys, and enum literal-id keys.
+ */
+export type KeyExpression = Exclude<ExpressionValue, ExpressionSpread>;
+/**
+ * Form of a key for class/interface members and enum members.
+ *
+ * - `{ kind: 'private' }` — `#name` private identifier key (class members only).
+ *   The owning symbol's `name` field carries the full `#name` source form.
+ * - Otherwise — a `KeyExpression` carrying the structured key form. For
+ *   computed keys (`[expr]`), the inner expression's `importSource` is
+ *   resolved when it is an imported identifier.
+ *
+ * Object literal property keys use {@link KeyExpression} directly (private
+ * keys are not valid in object literals).
+ */
+export type SymbolKey = {
+    kind: 'private';
+} | KeyExpression;
 export interface ExpressionArray {
     kind: 'array';
     elements: ExpressionValue[];
@@ -92,7 +150,10 @@ export type SymbolKind = 'function' | 'method' | 'class' | 'variable' | 'type' |
 /**
  * TypeScript declaration modifiers attached to a symbol.
  */
-export type Modifier = 'async' | 'static' | 'abstract' | 'readonly' | 'private' | 'protected' | 'public' | 'override' | 'declare' | 'const';
+export type Modifier = 'async' | 'static' | 'abstract' | 'readonly' | 'private' | 'protected' | 'public' | 'override' | 'declare' | 'const'
+/** TC39 auto-accessor: `accessor x = 1`. Marks `AccessorProperty` /
+ *  `TSAbstractAccessorProperty` class members. */
+ | 'accessor';
 /**
  * A function/method parameter.
  */
@@ -180,14 +241,20 @@ export interface ExtractedSymbol {
     /** For methods: distinguishes `'method'`, `'getter'`, `'setter'`, or `'constructor'`. */
     methodKind?: 'method' | 'getter' | 'setter' | 'constructor';
     /**
-     * Syntactic form of a class/interface member key. Omitted for plain identifier
-     * keys (the default). Distinguishes:
-     * - `'private'` — `#name` (PrivateIdentifier). `name` field is the bare name without `#`.
-     * - `'literal'` — string-literal key, e.g. `'my-method'() {}`. `name` is the literal value.
-     * - `'computed'` — `[expr]` key. `name` is the source text of the bracket expression
-     *   (e.g. `'[Symbol.iterator]'`).
+     * Form of the member key when it is not a plain identifier. Omitted for
+     * identifier-keyed members (`name` carries the identifier in that case).
+     *
+     * - `{ kind: 'private' }` — `#name` private member. `name` carries the
+     *   full source form including `#` (e.g. `'#secret'`).
+     * - `{ kind: 'string' | 'number' | 'bigint', value }` — non-computed
+     *   literal key (e.g. `'my-method'() {}`, `42 = 'x'`).
+     * - any other `ExpressionValue` shape — computed key `[expr]`, with
+     *   the inner expression's structure (and `importSource` resolution
+     *   for imported identifiers) preserved.
+     *
+     * For object literal property keys, see {@link ExpressionObjectProperty.key}.
      */
-    keyKind?: 'private' | 'literal' | 'computed';
+    key?: SymbolKey;
     /** Function/method parameters. Present for functions, methods, and constructors. */
     parameters?: Parameter[];
     /** Return type annotation as source text. */
@@ -252,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

@@ -11,7 +11,7 @@ export { patternSearch } from "./search/pattern-search";
 export type { PatternMatch, PatternCapture } from "./search/pattern-search";
 export type { IndexResult } from "./indexer/index-coordinator";
 export type { ProjectBoundary } from "./common/project-discovery";
-export type { CodeRelation, ExtractedSymbol, SymbolKind, Decorator, Parameter, Heritage, Modifier, JsDocBlock, JsDocTag, ExpressionValue, ExpressionLiteral, ExpressionIdentifier, ExpressionMember, ExpressionCall, ExpressionNew, ExpressionObject, ExpressionObjectProperty, ExpressionArray, ExpressionSpread, ExpressionFunction, ExpressionTemplate, ExpressionUnresolvable } from "./extractor/types";
+export type { CodeRelation, ExtractedSymbol, SymbolKey, KeyExpression, SymbolKind, Decorator, Parameter, Heritage, Modifier, JsDocBlock, JsDocTag, ExpressionValue, ExpressionLiteral, ExpressionIdentifier, ExpressionMember, ExpressionCall, ExpressionNew, ExpressionObject, ExpressionObjectEntry, ExpressionObjectProperty, ExpressionArray, ExpressionSpread, ExpressionFunction, ExpressionTemplate, ExpressionUnresolvable } from "./extractor/types";
 export type { SymbolStats } from "./store/repositories/symbol.repository";
 export type { WatcherRole, FileChangeEvent } from "./watcher/types";
 export type { ParsedFile } from "./parser/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.25.0",
+  "version": "0.26.1",
   "description": "TypeScript code indexing and dependency graph engine for Bun",
   "license": "MIT",
   "repository": {