@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.104

package/dist/js-ts-safe-merge-ledger-validation.js

@@ -0,0 +1,92 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict } from './js-ts-safe-merge-context.js';
+
+export function validateLedgerUniqueness(ledger, context) {
+  const keyOwners = new Map();
+  for (const entry of ledger.entries) {
+    const existing = keyOwners.get(entry.key);
+    if (existing) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.duplicateName,
+        gateId: JsTsSafeMergeGateIds.uniqueNames,
+        side: ledger.label,
+        message: `${ledger.label} source has duplicate top-level ledger keys.`,
+        details: { key: entry.key, firstOffset: existing.start, secondOffset: entry.start }
+      });
+    } else {
+      keyOwners.set(entry.key, entry);
+    }
+  }
+
+  const nameOwners = new Map();
+  for (const entry of ledger.entries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      const existing = nameOwners.get(nameKey);
+      if (existing) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: ledger.label,
+          message: `${ledger.label} source has duplicate top-level names.`,
+          details: { name, firstOffset: existing.start, secondOffset: entry.start }
+        });
+      } else {
+        nameOwners.set(nameKey, entry);
+      }
+    }
+  }
+
+  for (const entry of ledger.entries.filter((item) => item.kind === 'import')) {
+    validateUniqueImportSpecifiers(entry, ledger.label, context);
+  }
+}
+
+function validateUniqueImportSpecifiers(entry, side, context) {
+  const localNames = new Map();
+  const specifiers = [
+    ...(entry.importInfo.defaultLocalName ? [{ localName: entry.importInfo.defaultLocalName, canonical: `default:${entry.importInfo.defaultLocalName}` }] : []),
+    ...(entry.importInfo.namespaceLocalName ? [{ localName: entry.importInfo.namespaceLocalName, canonical: `namespace:${entry.importInfo.namespaceLocalName}` }] : []),
+    ...entry.importInfo.specifiers
+  ];
+  for (const specifier of specifiers) {
+    const existing = localNames.get(specifier.localName);
+    if (existing) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.duplicateName,
+        gateId: JsTsSafeMergeGateIds.uniqueNames,
+        side,
+        message: `${side} source has duplicate import binding names.`,
+        details: { importKey: entry.key, localName: specifier.localName, first: existing.canonical, second: specifier.canonical }
+      });
+    } else {
+      localNames.set(specifier.localName, specifier);
+    }
+  }
+}
+
+export function indexBaseLedger(base, context) {
+  const entriesByKey = new Map();
+  for (const entry of base.entries) entriesByKey.set(entry.key, entry);
+  const names = new Set();
+  for (const entry of base.entries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      if (names.has(nameKey)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'base',
+          message: 'Base source has duplicate declaration or export names.',
+          details: { name }
+        });
+      }
+      names.add(nameKey);
+    }
+  }
+  return {
+    entriesByKey,
+    orderedKeys: base.entries.map((entry) => entry.key),
+    names
+  };
+}

package/dist/js-ts-safe-merge-ledger.js

@@ -0,0 +1,85 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict } from './js-ts-safe-merge-context.js';
+import { classifyStatement, importSpecifierCanonical } from './js-ts-safe-merge-parse-declarations.js';
+import { findStatementEnd, skipTopLevelTrivia } from './js-ts-safe-merge-parse-statements.js';
+
+export function scanJsTsTopLevelLedger(sourceText, label, context) {
+  const entries = [];
+  let offset = 0;
+  while (offset < sourceText.length) {
+    const skipped = skipTopLevelTrivia(sourceText, offset);
+    if (skipped.error) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains unterminated top-level trivia.`,
+        details: { offset, error: skipped.error }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    offset = skipped.offset;
+    if (offset >= sourceText.length) break;
+
+    if (sourceText[offset] === '@') {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.unsupportedDecorator,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains decorator syntax that is not safe for ledger merge anchors.`,
+        details: { offset, reasonCode: 'unsupported-js-ts-syntax', preview: sourceText.slice(offset, Math.min(sourceText.length, offset + 80)) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+
+    const end = findStatementEnd(sourceText, offset);
+    if (end.error) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.malformedSyntax,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains a top-level statement the narrow ledger cannot bound.`,
+        details: { offset, error: end.error, preview: sourceText.slice(offset, Math.min(sourceText.length, offset + 80)) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+
+    const statementText = sourceText.slice(offset, end.offset);
+    const entry = classifyStatement(statementText, offset, end.offset);
+    if (entry?.unsupported) {
+      addConflict(context, {
+        code: entry.unsupported.code,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains syntax that is not safe for automatic JS/TS ledger merge.`,
+        details: { offset, ...entry.unsupported.details, statement: statementText.trim().slice(0, 120) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    if (!entry) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains an unsupported top-level statement.`,
+        details: { offset, statement: statementText.trim().slice(0, 120) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    entries.push(entry);
+    offset = end.offset;
+  }
+  return createLedger(label, sourceText, entries);
+}
+
+function createLedger(label, sourceText, entries) {
+  return {
+    label,
+    sourceText,
+    entries,
+    baseEntries: entries.filter((entry) => entry.kind === 'import' || entry.kind === 'declaration' || entry.kind === 'export')
+  };
+}
+
+export { importSpecifierCanonical } from './js-ts-safe-merge-parse-declarations.js';
+export { indexBaseLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger-validation.js';

package/dist/js-ts-safe-merge-parse-declarations.js

@@ -0,0 +1,210 @@
+import { JsTsSafeMergeConflictCodes, identifierRegExp } from './js-ts-safe-merge-constants.js';
+
+export function classifyStatement(text, start, end) {
+  const importInfo = parseImportInfo(text);
+  if (importInfo) {
+    return {
+      kind: 'import',
+      key: importLedgerKey(importInfo),
+      text,
+      start,
+      end,
+      importInfo,
+      names: importInfo.specifiers.map((specifier) => specifier.localName).filter(Boolean)
+    };
+  }
+  const declarationInfo = parseDeclarationInfo(text);
+  if (declarationInfo) {
+    const unsupported = unsupportedDeclarationPolicy(text, declarationInfo);
+    if (unsupported) return { unsupported, text, start, end };
+    return {
+      kind: declarationInfo.kind,
+      key: `${declarationInfo.kind}:${declarationInfo.names.join('|')}`,
+      text,
+      start,
+      end,
+      declarationInfo,
+      names: declarationInfo.names
+    };
+  }
+  return undefined;
+}
+
+function parseImportInfo(text) {
+  const trimmed = text.trim();
+  const sideEffect = trimmed.match(/^import\s+(['"])([^'"]+)\1\s*;?$/s);
+  if (sideEffect) {
+    return {
+      moduleSpecifier: sideEffect[2],
+      quote: sideEffect[1],
+      typeOnly: false,
+      sideEffectOnly: true,
+      defaultLocalName: undefined,
+      namespaceLocalName: undefined,
+      specifiers: []
+    };
+  }
+
+  const match = trimmed.match(/^import\s+(type\s+)?([\s\S]+?)\s+from\s+(['"])([^'"]+)\3\s*;?$/s);
+  if (!match) return undefined;
+  const typeOnly = Boolean(match[1]);
+  const clause = match[2].trim();
+  const parsedClause = parseImportClause(clause, { typeOnly });
+  if (!parsedClause) return undefined;
+  return {
+    moduleSpecifier: match[4],
+    quote: match[3],
+    typeOnly,
+    sideEffectOnly: false,
+    ...parsedClause
+  };
+}
+
+function parseImportClause(clause, options) {
+  const namespace = clause.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+  if (namespace) {
+    return {
+      defaultLocalName: undefined,
+      namespaceLocalName: namespace[1],
+      specifiers: []
+    };
+  }
+
+  const named = clause.match(/\{([\s\S]*)\}/);
+  if (!named) {
+    if (!identifierRegExp.test(clause)) return undefined;
+    return {
+      defaultLocalName: clause,
+      namespaceLocalName: undefined,
+      specifiers: []
+    };
+  }
+
+  const beforeNamed = clause.slice(0, named.index).trim();
+  const afterNamed = clause.slice(named.index + named[0].length).trim();
+  if (afterNamed) return undefined;
+  let defaultLocalName;
+  if (beforeNamed) {
+    const defaultText = beforeNamed.replace(/,$/, '').trim();
+    if (!identifierRegExp.test(defaultText)) return undefined;
+    defaultLocalName = defaultText;
+  }
+
+  const specifiers = splitCommaList(named[1]).map((part) => parseImportSpecifier(part, options)).filter(Boolean);
+  if (splitCommaList(named[1]).filter((part) => part.trim()).length !== specifiers.length) return undefined;
+  return {
+    defaultLocalName,
+    namespaceLocalName: undefined,
+    specifiers
+  };
+}
+
+function parseImportSpecifier(raw, options) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  let typeOnly = Boolean(options.typeOnly);
+  if (text.startsWith('type ')) {
+    typeOnly = true;
+    text = text.slice(5).trim();
+  }
+  const match = text.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+  if (!match) return undefined;
+  const importedName = match[1];
+  const localName = match[2] ?? importedName;
+  return {
+    importedName,
+    localName,
+    typeOnly,
+    canonical: importSpecifierCanonical({ importedName, localName, typeOnly })
+  };
+}
+
+function parseDeclarationInfo(text) {
+  const trimmed = text.trim();
+  const defaultFunction = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?(?:\s+([A-Za-z_$][\w$]*))?\b/);
+  if (defaultFunction) return { kind: 'declaration', names: ['default'], declarationKind: 'function', exported: true, defaultExport: true };
+  const defaultClass = trimmed.match(/^export\s+default\s+(?:abstract\s+)?class(?:\s+([A-Za-z_$][\w$]*))?\b/);
+  if (defaultClass) return { kind: 'declaration', names: ['default'], declarationKind: 'class', exported: true, defaultExport: true };
+
+  const namedExport = trimmed.match(/^export\s+(type\s+)?\{([\s\S]+)\}\s*;?$/);
+  if (namedExport) {
+    const names = splitCommaList(namedExport[2]).map((part) => parseExportSpecifierName(part)).filter(Boolean);
+    const expectedCount = splitCommaList(namedExport[2]).filter((part) => part.trim()).length;
+    if (names.length !== expectedCount || names.length === 0) return undefined;
+    return { kind: 'export', names, declarationKind: 'export-list', exported: true, typeOnly: Boolean(namedExport[1]) };
+  }
+
+  const source = trimmed
+    .replace(/^export\s+/, '')
+    .replace(/^declare\s+/, '');
+  const functionMatch = source.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)\b/);
+  if (functionMatch) return { kind: 'declaration', names: [functionMatch[1]], declarationKind: 'function', exported: trimmed.startsWith('export ') };
+  const classMatch = source.match(/^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)\b/);
+  if (classMatch) return { kind: 'declaration', names: [classMatch[1]], declarationKind: 'class', exported: trimmed.startsWith('export ') };
+  const interfaceMatch = source.match(/^interface\s+([A-Za-z_$][\w$]*)\b/);
+  if (interfaceMatch) return { kind: 'declaration', names: [interfaceMatch[1]], declarationKind: 'interface', exported: trimmed.startsWith('export ') };
+  const typeMatch = source.match(/^type\s+([A-Za-z_$][\w$]*)\b/);
+  if (typeMatch) return { kind: 'declaration', names: [typeMatch[1]], declarationKind: 'type', exported: trimmed.startsWith('export ') };
+  const enumMatch = source.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)\b/);
+  if (enumMatch) return { kind: 'declaration', names: [enumMatch[1]], declarationKind: 'enum', exported: trimmed.startsWith('export ') };
+  const moduleMatch = source.match(/^(?:namespace|module)\s+([A-Za-z_$][\w$.]*)\b/);
+  if (moduleMatch) return { kind: 'declaration', names: [moduleMatch[1]], declarationKind: 'module', exported: trimmed.startsWith('export ') };
+  const variableMatch = source.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/);
+  if (variableMatch) return { kind: 'declaration', names: [variableMatch[1]], declarationKind: 'variable', exported: trimmed.startsWith('export ') };
+  return undefined;
+}
+
+function unsupportedDeclarationPolicy(text, declarationInfo) {
+  const trimmed = text.trim();
+  if (/^\s*@/m.test(text)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.unsupportedDecorator,
+      details: { reasonCode: 'unsupported-decorator-merge-anchor', declarationKind: declarationInfo.declarationKind }
+    };
+  }
+  if (declarationInfo.declarationKind === 'function' && !trimmed.includes('{') && /;\s*$/.test(trimmed)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.unsupportedOverload,
+      details: { reasonCode: 'unsupported-overload-merge-anchor', names: declarationInfo.names }
+    };
+  }
+  if (hasComputedMemberKey(text)) {
+    return {
+      code: JsTsSafeMergeConflictCodes.computedKey,
+      details: { reasonCode: 'computed-key', declarationKind: declarationInfo.declarationKind, names: declarationInfo.names }
+    };
+  }
+  return undefined;
+}
+
+function hasComputedMemberKey(text) {
+  return /(?:^|[\n{,;])\s*(?:readonly\s+)?\[[^\]\n]+\]\??\s*(?::|\()/m.test(text);
+}
+
+function parseExportSpecifierName(raw) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  if (text.startsWith('type ')) text = text.slice(5).trim();
+  const match = text.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+  if (!match) return undefined;
+  return match[2] ?? match[1];
+}
+
+function splitCommaList(raw) {
+  return String(raw ?? '').split(',');
+}
+
+function importLedgerKey(importInfo) {
+  if (importInfo.sideEffectOnly) return `import:side-effect:${importInfo.moduleSpecifier}`;
+  return [
+    'import:named',
+    importInfo.moduleSpecifier,
+    importInfo.typeOnly ? 'type' : 'value',
+    importInfo.defaultLocalName ?? '',
+    importInfo.namespaceLocalName ?? ''
+  ].join(':');
+}
+
+export function importSpecifierCanonical(specifier) {
+  return `${specifier.typeOnly ? 'type ' : ''}${specifier.importedName}${specifier.localName === specifier.importedName ? '' : ` as ${specifier.localName}`}`;
+}

package/dist/js-ts-safe-merge-parse-statements.js

@@ -0,0 +1,155 @@
+export function skipTopLevelTrivia(sourceText, offset) {
+  let index = offset;
+  while (index < sourceText.length) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      index = consumeLineComment(sourceText, index + 2);
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      const end = sourceText.indexOf('*/', index + 2);
+      if (end === -1) return { offset: index, error: 'unterminated-block-comment' };
+      index = end + 2;
+      continue;
+    }
+    break;
+  }
+  return { offset: index };
+}
+
+function consumeLineComment(sourceText, offset) {
+  const lineEnd = sourceText.indexOf('\n', offset);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+export function findStatementEnd(sourceText, start) {
+  const text = sourceText.slice(start);
+  const endOnBalancedBlock = statementCanEndOnBalancedBlock(text);
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let openedBrace = false;
+  let quote;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escaped = false;
+
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+
+    if (inLineComment) {
+      if (char === '\n') inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (inTemplate) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '`') {
+        inTemplate = false;
+      }
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === '`') {
+      inTemplate = true;
+      continue;
+    }
+    if (char === '(') {
+      parenDepth += 1;
+      continue;
+    }
+    if (char === ')') {
+      parenDepth -= 1;
+      if (parenDepth < 0) return { error: 'unbalanced-paren' };
+      continue;
+    }
+    if (char === '[') {
+      bracketDepth += 1;
+      continue;
+    }
+    if (char === ']') {
+      bracketDepth -= 1;
+      if (bracketDepth < 0) return { error: 'unbalanced-bracket' };
+      continue;
+    }
+    if (char === '{') {
+      braceDepth += 1;
+      openedBrace = true;
+      continue;
+    }
+    if (char === '}') {
+      braceDepth -= 1;
+      if (braceDepth < 0) return { error: 'unbalanced-brace' };
+      if (endOnBalancedBlock && openedBrace && braceDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+        return { offset: consumeOptionalSameLineSemicolon(sourceText, index + 1) };
+      }
+      continue;
+    }
+    if (char === ';' && braceDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+      return { offset: index + 1 };
+    }
+  }
+
+  if (quote || inTemplate || inBlockComment || braceDepth !== 0 || parenDepth !== 0 || bracketDepth !== 0) {
+    return { error: 'unterminated-statement' };
+  }
+  return { error: 'missing-top-level-statement-terminator' };
+}
+
+function consumeOptionalSameLineSemicolon(sourceText, offset) {
+  let index = offset;
+  while (index < sourceText.length && (sourceText[index] === ' ' || sourceText[index] === '\t')) index += 1;
+  if (sourceText[index] === ';') return index + 1;
+  return offset;
+}
+
+function statementCanEndOnBalancedBlock(text) {
+  const trimmed = text.trimStart();
+  return new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:async\\s+)?function\\*?\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:abstract\\s+)?class\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?interface\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:const\\s+)?enum\\b`).test(trimmed)
+    || new RegExp(`^(?:export\\s+)?(?:declare\\s+)?(?:namespace|module)\\b`).test(trimmed)
+    || new RegExp(`^export\\s+default\\s+(?:async\\s+)?function\\*?\\b`).test(trimmed)
+    || new RegExp(`^export\\s+default\\s+(?:abstract\\s+)?class\\b`).test(trimmed);
+}