@shapeshift-labs/frontier-lang-compiler 0.2.144 → 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/dist/js-ts-semantic-merge-member-source.js

@@ -17,7 +17,7 @@ function removePreparedMemberAdditions(sourceText, preparedRegions, side) {
   const replacements = preparedRegions
     .map((region) => ({
       range: region[side],
-      replacement: removeMembersFromBody(region[side].body, region[`${side}AddedMembers`] ?? [], region.kind)
+      replacement: removeMembersFromBody(region[side].body, region[`${side}AddedMembers`] ?? [], region.kind, region.base.body)
     }))
     .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
   for (const { range, replacement } of replacements) {
@@ -88,16 +88,25 @@ function appendReadyBody(before, kind) {
   return `${before.replace(/\s*$/, '')},`;
 }
 
-function removeMembersFromBody(body, members, kind) {
+function removeMembersFromBody(body, members, kind, baseBody) {
   let output = body;
   for (const member of [...members].sort((left, right) => right.start - left.start || right.end - left.end)) {
     output = `${output.slice(0, member.start)}${output.slice(member.end)}`;
   }
   if (kind !== 'object') return output;
+  if (typeof baseBody === 'string' && sameObjectBodyIgnoringTrailingDelimiter(output, baseBody)) return baseBody;
   const trailing = String(body ?? '').match(/\s*$/)?.[0] ?? '';
   return output.replace(/,\s*$/, trailing);
 }
 
+function sameObjectBodyIgnoringTrailingDelimiter(left, right) {
+  return normalizeObjectTrailingDelimiter(left) === normalizeObjectTrailingDelimiter(right);
+}
+
+function normalizeObjectTrailingDelimiter(body) {
+  return String(body ?? '').replace(/,\s*$/, (trailing) => trailing.replace(',', ''));
+}
+
 function minimumIndent(lines) {
   const indents = lines.filter((line) => line.trim()).map(leadingWhitespace);
   return indents.length ? Math.min(...indents) : 0;

package/package.json

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