@treeseed/sdk 0.1.1 → 0.3.0

package/dist/field-aliases.d.ts

@@ -0,0 +1,11 @@
+export interface TreeseedFieldAliasBinding {
+    key: string;
+    aliases?: string[];
+    normalize?: (value: unknown) => unknown;
+}
+export type TreeseedFieldAliasRegistry<TBinding extends TreeseedFieldAliasBinding = TreeseedFieldAliasBinding> = Record<string, TBinding>;
+export declare function resolveAliasedField<TBinding extends TreeseedFieldAliasBinding>(registry: TreeseedFieldAliasRegistry<TBinding>, requestedField: string): TBinding;
+export declare function normalizeAliasedRecord<TBinding extends TreeseedFieldAliasBinding>(registry: TreeseedFieldAliasRegistry<TBinding>, source: Record<string, unknown>): {
+    [x: string]: unknown;
+};
+export declare function preprocessAliasedRecord<TBinding extends TreeseedFieldAliasBinding>(registry: TreeseedFieldAliasRegistry<TBinding>, value: unknown): unknown;

package/dist/field-aliases.js

@@ -0,0 +1,41 @@
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeFieldName(value) {
+  return value.trim().toLowerCase();
+}
+function resolveAliasedField(registry, requestedField) {
+  const normalizedRequested = normalizeFieldName(requestedField);
+  for (const [canonicalKey, binding] of Object.entries(registry)) {
+    const aliases = (binding.aliases ?? []).map(normalizeFieldName);
+    if (normalizeFieldName(canonicalKey) === normalizedRequested || aliases.includes(normalizedRequested)) {
+      return { ...binding, key: canonicalKey };
+    }
+  }
+  throw new Error(`Unknown aliased field "${requestedField}".`);
+}
+function normalizeAliasedRecord(registry, source) {
+  if (!isRecord(source)) {
+    return source;
+  }
+  const next = { ...source };
+  for (const [canonicalKey, binding] of Object.entries(registry)) {
+    for (const candidate of [canonicalKey, ...binding.aliases ?? []]) {
+      if (!(candidate in source)) {
+        continue;
+      }
+      const value = source[candidate];
+      next[canonicalKey] = typeof binding.normalize === "function" ? binding.normalize(value) : value;
+      break;
+    }
+  }
+  return next;
+}
+function preprocessAliasedRecord(registry, value) {
+  return isRecord(value) ? normalizeAliasedRecord(registry, value) : value;
+}
+export {
+  normalizeAliasedRecord,
+  preprocessAliasedRecord,
+  resolveAliasedField
+};

package/dist/graph/build.d.ts

@@ -0,0 +1,19 @@
+import type { SdkGraphEdge, SdkGraphNode, SdkModelRegistry } from '../sdk-types.ts';
+import { type GraphDelta, type GraphFileCatalogEntry, type GraphMetrics, type GraphValidation, type ParsedGraphDocument } from './schema.ts';
+export type GraphBuildState = {
+    modelSignature: string;
+    documents: ParsedGraphDocument[];
+    nodes: SdkGraphNode[];
+    edges: SdkGraphEdge[];
+    catalog: GraphFileCatalogEntry[];
+    metrics: GraphMetrics;
+    validation: GraphValidation;
+    delta: GraphDelta;
+    snapshotRoot: string;
+};
+export declare function loadGraphSnapshot(repoRoot: string, models: SdkModelRegistry): Promise<GraphBuildState | null>;
+export declare function saveGraphSnapshot(state: GraphBuildState): Promise<void>;
+export declare function refreshGraphBuildState(repoRoot: string, models: SdkModelRegistry, request?: {
+    paths?: string[];
+}, priorState?: GraphBuildState | null): Promise<GraphBuildState>;
+export declare function clearGraphSnapshot(repoRoot: string): Promise<void>;