@shapeshift-labs/frontier-lang-compiler 0.2.145 → 0.2.146

package/dist/internal/index-impl/syntaxDeclaration.js

@@ -15,6 +15,29 @@ export function syntaxDeclaration(node, nativeNodeId, input) {
   if (kind === 'ClassDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'class');
   if (kind === 'TSInterfaceDeclaration' || kind === 'InterfaceDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'interface');
   if (kind === 'TSTypeAliasDeclaration' || kind === 'TypeAliasDeclaration') return namedDeclaration(input, nativeNodeId, node.id, 'type');
+  if (kind === 'TSModuleDeclaration' || kind === 'ModuleDeclaration') return syntaxModuleDeclaration(input, nativeNodeId, node);
   if (kind === 'VariableDeclarator') return namedDeclaration(input, nativeNodeId, node.id, 'variable');
   return undefined;
 }
+
+function syntaxModuleDeclaration(input, nativeNodeId, node) {
+  const name = syntaxName(node.id ?? node.name);
+  if (!name) return undefined;
+  return {
+    ...declarationRecord(input, nativeNodeId, name, 'module', 'definition'),
+    metadata: {
+      scan: 'syntax-module-declaration',
+      moduleName: name,
+      namespace: name
+    }
+  };
+}
+
+function syntaxName(node) {
+  if (!node) return undefined;
+  if (typeof node === 'string') return node;
+  if (typeof node.name === 'string') return node.name;
+  if (typeof node.value === 'string') return node.value;
+  if (typeof node.text === 'string') return node.text;
+  return undefined;
+}

package/dist/internal/index-impl/typeScriptDeclaration.js

@@ -14,6 +14,7 @@ export function typeScriptDeclaration(node, kind, nativeNodeId, input, options =
   if (kind === 'ClassDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'class')), exportedEntries, enrich, node);
   if (kind === 'InterfaceDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'interface')), exportedEntries, enrich, node);
   if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'type')), exportedEntries, enrich, node);
+  if (kind === 'ModuleDeclaration') return declarationWithExports(enrich(moduleDeclaration(input, nativeNodeId, node), node.name ?? node), exportedEntries, enrich, node);
   if (kind === 'VariableDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'variable'));
   if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'method'));
   return undefined;
@@ -25,6 +26,19 @@ function declarationWithExports(declaration, exportedEntries, enrich, node) {
   return exports.length ? [declaration, ...exports] : declaration;
 }
 
+function moduleDeclaration(input, nativeNodeId, node) {
+  const name = stringFromTsExpression(node.name);
+  if (!name) return undefined;
+  return {
+    ...declarationRecord(input, nativeNodeId, name, 'module', 'definition'),
+    metadata: compactRecord({
+      scan: 'typescript-module-declaration',
+      moduleName: name,
+      namespace: name
+    })
+  };
+}
+
 function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
   if (!declaration) return declaration;
   const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();

package/dist/internal/index-impl/typeScriptExportedDeclarationEntries.js

@@ -92,6 +92,7 @@ function exportedSymbolKind(kind) {
   if (kind === 'ClassDeclaration') return 'class';
   if (kind === 'InterfaceDeclaration') return 'interface';
   if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return 'type';
+  if (kind === 'ModuleDeclaration') return 'module';
   return undefined;
 }
 

package/dist/js-ts-safe-project-merge-graph.js

@@ -1,6 +1,7 @@
 import { idFragment } from './native-import-utils.js';
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
+import { augmentProjectSymbolGraphPublicContracts } from './js-ts-safe-project-merge-public-contracts.js';
 import { createNativeProjectImportResult } from './internal/index-impl/createNativeProjectImportResult.js';
 import { importNativeSource } from './internal/index-impl/importNativeSource.js';
 import {
@@ -92,22 +93,26 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
       ...(stageName === 'output' ? { outputProjectImportSource: projectGraphImportSource } : {})
     }
   }, imports);
-  const edgeLimitConflicts = projectGraphEdgeLimitConflicts(limits, stageName, projectImport.projectSymbolGraph);
+  const projectSymbolGraph = augmentProjectSymbolGraphPublicContracts(projectImport.projectSymbolGraph, files, input, stageName);
+  const stageProjectImport = projectSymbolGraph === projectImport.projectSymbolGraph
+    ? projectImport
+    : attachProjectSymbolGraph(projectImport, projectSymbolGraph);
+  const edgeLimitConflicts = projectGraphEdgeLimitConflicts(limits, stageName, projectSymbolGraph);
   const serialized = projectGraphSerializedLimitConflict(limits, stageName, {
-    projectImport,
-    projectSymbolGraph: projectImport.projectSymbolGraph
+    projectImport: stageProjectImport,
+    projectSymbolGraph
   });
   const limitConflicts = [...edgeLimitConflicts, serialized.conflict].filter(Boolean);
   if (limitConflicts.length) {
-    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, projectImport.projectSymbolGraph, limitConflicts, serialized.serializedBytes);
+    return limitedProjectGraphStage(stageName, projectGraphImportSource, sourceStats, projectSymbolGraph, limitConflicts, serialized.serializedBytes);
   }
   return {
     kind: 'frontier.lang.jsTsProjectGraphStage',
     version: 1,
     stage: stageName,
-    projectImport,
-    projectSymbolGraph: projectImport.projectSymbolGraph,
-    summary: projectGraphStageSummary(stageName, projectImport.projectSymbolGraph, projectGraphImportSource, sourceStats, serialized.serializedBytes, [])
+    projectImport: stageProjectImport,
+    projectSymbolGraph,
+    summary: projectGraphStageSummary(stageName, projectSymbolGraph, projectGraphImportSource, sourceStats, serialized.serializedBytes, [])
   };
 }
 
@@ -215,6 +220,24 @@ function stageFile(file, sourceText, input) {
   });
 }
 
+function attachProjectSymbolGraph(projectImport, projectSymbolGraph) {
+  return {
+    ...projectImport,
+    projectSymbolGraph,
+    semanticIndex: projectImport.semanticIndex ? {
+      ...projectImport.semanticIndex,
+      metadata: {
+        ...projectImport.semanticIndex.metadata,
+        projectSymbolGraph
+      }
+    } : projectImport.semanticIndex,
+    metadata: {
+      ...projectImport.metadata,
+      projectSymbolGraph
+    }
+  };
+}
+
 function hashText(sourceText) {
   return hashSemanticValue(sourceText);
 }

package/dist/js-ts-safe-project-merge-public-contracts.js

@@ -0,0 +1,117 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { findContainer, normalizeKind, normalizeMemberText, parseMembers } from './js-ts-semantic-merge-parse.js';
+import { idFragment } from './native-import-utils.js';
+
+function augmentProjectSymbolGraphPublicContracts(projectSymbolGraph, files, input, stageName) {
+  const existingRegions = Array.isArray(projectSymbolGraph?.publicContractRegions) ? projectSymbolGraph.publicContractRegions : [];
+  const seenKeys = new Set(existingRegions.map((region) => region?.key).filter(Boolean));
+  const syntheticRegions = [];
+  for (const file of files) {
+    syntheticRegions.push(...syntheticPublicContractRegions(file, input, stageName, seenKeys));
+  }
+  if (!syntheticRegions.length) return projectSymbolGraph;
+  return {
+    ...projectSymbolGraph,
+    publicContractRegions: [...existingRegions, ...syntheticRegions]
+  };
+}
+
+function syntheticPublicContractRegions(file, input, stageName, seenKeys) {
+  if (typeof file?.sourceText !== 'string' || !file.sourcePath) return [];
+  const records = [];
+  for (const region of publicContractPolicyRegionsForPath(input, file.sourcePath)) {
+    const kind = normalizeKind(region?.kind);
+    if (!['interface', 'type', 'class'].includes(kind) || typeof region?.name !== 'string') continue;
+    const container = findContainer(file.sourceText, region);
+    if (container.reasonCodes.length || !isExportedContainer(file.sourceText, container.value)) continue;
+    const members = parseMembers(container.value.body, kind);
+    if (members.reasonCodes.length) continue;
+    const key = `source#${file.sourcePath}#export#${region.name}`;
+    if (seenKeys.has(key)) continue;
+    seenKeys.add(key);
+    records.push(syntheticPublicContractRegion(file, input, stageName, kind, region.name, key, members.members));
+  }
+  return records;
+}
+
+function syntheticPublicContractRegion(file, input, stageName, kind, name, key, members) {
+  const language = file.language ?? input.language ?? languageForPath(file.sourcePath);
+  const memberRecords = members.map((member) => compactRecord({
+    key: member.key,
+    memberKind: member.memberKind,
+    signature: normalizeMemberText(member.text, kind)
+  }));
+  const signatureHash = hashSemanticValue({
+    kind: 'frontier.lang.syntheticPublicContractSignature',
+    language,
+    sourcePath: file.sourcePath,
+    symbolName: name,
+    sourceKind: kind,
+    members: memberRecords
+  });
+  const contractHash = hashSemanticValue({
+    kind: 'frontier.lang.syntheticPublicContractRegionHash',
+    language,
+    sourcePath: file.sourcePath,
+    key,
+    symbolName: name,
+    symbolKind: 'export',
+    apiSurfaceKind: 'module-export',
+    exportedName: name,
+    edgeKind: 'export',
+    signatureHash
+  });
+  return compactRecord({
+    id: `region_${idFragment(stageName)}_${idFragment(key)}`,
+    key,
+    regionKind: 'export',
+    granularity: 'symbol',
+    language,
+    sourcePath: file.sourcePath,
+    sourceHash: file.sourceHash,
+    symbolId: `symbol:${language}:export:${idFragment(name)}`,
+    symbolName: name,
+    symbolKind: 'export',
+    publicContract: true,
+    exportedName: name,
+    edgeKind: 'export',
+    apiSurfaceKind: 'module-export',
+    signatureHash,
+    contractHash,
+    metadata: {
+      source: 'js-ts-safe-project-merge-policy',
+      projectGraphStage: stageName,
+      sourceKind: kind,
+      memberKeys: memberRecords.map((member) => member.key)
+    }
+  });
+}
+
+function publicContractPolicyRegionsForPath(input, sourcePath) {
+  const policy = input.policyByPath?.[sourcePath]
+    ?? input.mergePolicyByPath?.[sourcePath]
+    ?? input.policy
+    ?? input.mergePolicy;
+  const regions = Array.isArray(policy)
+    ? policy
+    : policy?.unorderedRegions
+      ?? policy?.unorderedMemberRegions
+      ?? policy?.safeList
+      ?? policy?.safeMembers
+      ?? [];
+  return Array.isArray(regions) ? regions : [];
+}
+
+function isExportedContainer(sourceText, container) {
+  if (!container) return false;
+  return /^\s*export\b/.test(sourceText.slice(container.start, container.openStart));
+}
+
+function languageForPath(sourcePath) {
+  const path = String(sourcePath ?? '').toLowerCase();
+  if (path.endsWith('.js') || path.endsWith('.jsx') || path.endsWith('.mjs') || path.endsWith('.cjs')) return 'javascript';
+  return 'typescript';
+}
+
+export { augmentProjectSymbolGraphPublicContracts };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.145",
+  "version": "0.2.146",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",