@shapeshift-labs/frontier-lang-compiler 0.2.112 → 0.2.113

package/README.md

@@ -213,6 +213,30 @@ When `includeOutputProjectSymbolGraph` is enabled, the same
 `moduleResolution` shape is used for output graph artifacts. Resolution is
 runtime-neutral: `baseUrl`, `paths`, `aliases`, and `compilerOptions.paths`
 are matched against the supplied project files, not the host filesystem.
+Bare package imports also get explicit package identity. If `packages` is
+provided, package export maps can resolve back to supplied workspace sources
+and record the selected export condition:
+
+```js
+const project = safeMergeJsTsProject({
+  includeOutputProjectSymbolGraph: true,
+  moduleResolution: {
+    packages: {
+      '@pkg/core': {
+        root: 'packages/core',
+        exports: { './utils': { import: './src/utils.ts', default: './dist/utils.js' } }
+      }
+    },
+    packageExportConditions: ['import', 'default']
+  },
+  baseFiles,
+  workerFiles,
+  headFiles
+});
+
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@pkg/core"
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
+```
 
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 

package/dist/declarations/native-project-module-resolution.d.ts

@@ -1,9 +1,26 @@
 export type NativeProjectModuleResolutionPaths = Readonly<Record<string, readonly string[] | string>>;
+export type NativeProjectPackageExportTarget = string | readonly string[] | NativeProjectPackageConditionalExports;
+export type NativeProjectPackageExports = NativeProjectPackageExportTarget | Readonly<Record<string, NativeProjectPackageExportTarget>>;
+
+export interface NativeProjectPackageConditionalExports {
+  readonly [condition: string]: NativeProjectPackageExportTarget;
+}
+
+export interface NativeProjectPackageResolutionOptions {
+  readonly root?: string;
+  readonly sourceRoot?: string;
+  readonly main?: string;
+  readonly types?: string;
+  readonly exports?: NativeProjectPackageExports;
+}
 
 export interface NativeProjectModuleResolutionOptions {
   readonly baseUrl?: string;
   readonly paths?: NativeProjectModuleResolutionPaths;
   readonly aliases?: NativeProjectModuleResolutionPaths;
+  readonly packages?: Readonly<Record<string, NativeProjectPackageResolutionOptions>>;
+  readonly conditions?: readonly string[];
+  readonly packageExportConditions?: readonly string[];
   readonly compilerOptions?: {
     readonly baseUrl?: string;
     readonly paths?: NativeProjectModuleResolutionPaths;

package/dist/declarations/native-project.d.ts

@@ -79,8 +79,6 @@ export interface ImportNativeProjectOptions {
 }
 
 export type NativeProjectSymbolGraphRemainingField =
-  | 'moduleEdges[].packageName'
-  | 'moduleEdges[].packageExportCondition'
   | 'reExportIdentities[].originSymbolId'
   | 'reExportIdentities[].exportedSymbolId'
   | 'reExportIdentities[].localSymbolId'
@@ -112,13 +110,15 @@ export interface NativeProjectSymbolGraphModuleEdgeRecord {
   readonly resolvedModulePath?: string;
   readonly targetDocumentId?: string;
   readonly resolvedTargetSymbolId?: string;
-  readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | string;
+  readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | 'package-source' | 'package-missing' | 'package-external' | string;
+  readonly packageName?: string;
+  readonly packageSubpath?: string;
+  readonly packageExportCondition?: string;
   readonly importKind?: string;
   readonly exportKind?: string;
   readonly importedName?: string;
   readonly exportedName?: string;
-  readonly localName?: string;
-  readonly namespace?: string;
+  readonly localName?: string; readonly namespace?: string;
   readonly isTypeOnly?: boolean;
   readonly isReExport?: boolean;
   readonly publicContract?: boolean;

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

@@ -141,8 +141,6 @@ export function createNativeProjectImportResult(input, imports) {
 }
 
 const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([
-  'moduleEdges[].packageName',
-  'moduleEdges[].packageExportCondition',
   'reExportIdentities[].originSymbolId',
   'reExportIdentities[].exportedSymbolId',
   'reExportIdentities[].localSymbolId',
@@ -244,6 +242,9 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolvedModulePath: resolution?.path,
     targetDocumentId: resolution?.documentId,
     resolutionKind: resolution?.kind,
+    packageName: resolution?.packageName,
+    packageSubpath: resolution?.packageSubpath,
+    packageExportCondition: resolution?.packageExportCondition,
     importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind),
     exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind),
     importedName: firstString(moduleEdge.importedName, value.importedName, symbolMetadata.importedName),

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

@@ -34,22 +34,25 @@ export function createProjectModuleSymbolResolver(symbols, documents) {
 }
 
 function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution) {
-  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution);
+  const packageInfo = packageSpecifierInfo(moduleSpecifier);
+  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution, packageInfo);
   let firstMissing;
   for (const candidate of candidates) {
     const target = moduleTargetDocument(candidate.path, documentsByPath);
-    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source` };
-    firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing` };
+    const packageFields = packageResolutionFields(candidate, packageInfo);
+    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source`, ...packageFields };
+    firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
   }
-  return firstMissing;
+  return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
 }
 
-function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}) {
+function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}, packageInfo) {
   const compilerOptions = moduleResolution.compilerOptions ?? {};
   const baseUrl = normalizeProjectPath(moduleResolution.baseUrl ?? compilerOptions.baseUrl ?? '');
   return uniquePaths([
     ...aliasCandidates(moduleSpecifier, moduleResolution.aliases, 'alias', baseUrl),
     ...aliasCandidates(moduleSpecifier, moduleResolution.paths ?? compilerOptions.paths, 'path-alias', baseUrl),
+    ...packageCandidates(packageInfo, moduleResolution),
     ...baseUrlCandidates(moduleSpecifier, baseUrl)
   ]);
 }
@@ -71,6 +74,74 @@ function baseUrlCandidates(moduleSpecifier, baseUrl) {
   return [{ kind: 'base-url', path: normalizeProjectPath(joinProjectPath(baseUrl, moduleSpecifier)) }];
 }
 
+function packageCandidates(packageInfo, moduleResolution = {}) {
+  if (!packageInfo) return [];
+  const options = moduleResolution.packages?.[packageInfo.packageName];
+  if (!options) return [];
+  const root = normalizeProjectPath(options.root ?? '');
+  const subpath = packageInfo.packageSubpath === '.' ? '' : packageInfo.packageSubpath.slice(2);
+  return uniquePaths([
+    ...packageExportCandidates(packageInfo, options, moduleResolution).map((candidate) => ({
+      ...candidate,
+      path: normalizeProjectPath(joinProjectPath(root, candidate.path))
+    })),
+    ...packageFallbackTargets(options, subpath).map((path) => ({
+      kind: 'package',
+      path: normalizeProjectPath(joinProjectPath(root, path)),
+      ...packageInfo
+    }))
+  ]);
+}
+
+function packageExportCandidates(packageInfo, options, moduleResolution) {
+  const targets = packageExportTargets(options.exports, packageInfo.packageSubpath, packageConditions(moduleResolution));
+  return targets.map((target) => ({
+    kind: 'package',
+    path: target.path,
+    packageExportCondition: target.condition,
+    ...packageInfo
+  }));
+}
+
+function packageExportTargets(exportsValue, subpath, conditions) {
+  if (!exportsValue) return [];
+  return exportTargetsForValue(exportMapValue(exportsValue, subpath), conditions);
+}
+
+function exportMapValue(exportsValue, subpath) {
+  if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? exportsValue : undefined;
+  return exportsValue[subpath] ?? patternExportMapValue(exportsValue, subpath);
+}
+
+function patternExportMapValue(exportsValue, subpath) {
+  for (const [pattern, target] of Object.entries(exportsValue)) {
+    const capture = patternCapture(subpath, pattern);
+    if (capture !== undefined) return replaceExportTargetCapture(target, capture);
+  }
+  return undefined;
+}
+
+function replaceExportTargetCapture(target, capture) {
+  if (typeof target === 'string') return target.replace('*', capture);
+  if (Array.isArray(target)) return target.map((entry) => replaceExportTargetCapture(entry, capture));
+  if (!isRecord(target)) return target;
+  return Object.fromEntries(Object.entries(target).map(([key, value]) => [key, replaceExportTargetCapture(value, capture)]));
+}
+
+function exportTargetsForValue(value, conditions, condition) {
+  if (!value) return [];
+  if (typeof value === 'string') return [{ path: value, condition }];
+  if (Array.isArray(value)) return value.flatMap((entry) => exportTargetsForValue(entry, conditions, condition));
+  if (!isRecord(value)) return [];
+  return conditions.flatMap((key) => exportTargetsForValue(value[key], conditions, key));
+}
+
+function packageFallbackTargets(options, subpath) {
+  const sourceRoot = normalizeProjectPath(options.sourceRoot ?? 'src');
+  if (subpath) return [joinProjectPath(sourceRoot, subpath), subpath];
+  return [options.types, options.main, joinProjectPath(sourceRoot, 'index')].filter(Boolean);
+}
+
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
     const document = documentsByPath.get(candidate);
@@ -80,7 +151,7 @@ function moduleTargetDocument(path, documentsByPath) {
 }
 
 function modulePathCandidates(path) {
-  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}/index.js`, `${path}/index.ts`];
+  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}.d.ts`, `${path}/index.js`, `${path}/index.ts`, `${path}/index.d.ts`];
 }
 
 function targetExportName(edge) {
@@ -114,6 +185,34 @@ function joinProjectPath(left, right) {
   return left ? `${left}/${right}` : String(right);
 }
 
+function packageSpecifierInfo(moduleSpecifier) {
+  if (!moduleSpecifier || String(moduleSpecifier).startsWith('#')) return undefined;
+  const parts = String(moduleSpecifier).split('/');
+  if (!parts[0] || parts[0] === '.' || parts[0] === '..') return undefined;
+  const scoped = parts[0].startsWith('@');
+  if (scoped && parts.length < 2) return undefined;
+  const packageName = scoped ? `${parts[0]}/${parts[1]}` : parts[0];
+  const rest = parts.slice(scoped ? 2 : 1).join('/');
+  return { packageName, packageSubpath: rest ? `./${rest}` : '.' };
+}
+
+function packageResolutionFields(candidate, packageInfo) {
+  if (!candidate.packageName && candidate.kind !== 'package') return {};
+  return {
+    packageName: candidate.packageName ?? packageInfo?.packageName,
+    packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath,
+    packageExportCondition: candidate.packageExportCondition
+  };
+}
+
+function packageConditions(moduleResolution = {}) {
+  return moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'];
+}
+
+function isRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
 function normalizeProjectPath(path) {
   const parts = [];
   for (const part of String(path).split('/')) {

package/package.json

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