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

package/dist/js-ts-semantic-merge-contracts.js

@@ -0,0 +1,217 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, normalizeSemanticMergeReadiness, uniqueStrings } from './native-import-utils.js';
+
+export const JsTsSemanticMergeConflictClasses = Object.freeze([
+  'same-token-edit',
+  'same-region-edit',
+  'delete-modify',
+  'move-edit',
+  'rename-rename',
+  'import-order',
+  'type-surface-drift',
+  'trivia-preservation',
+  'behavior-evidence-needed'
+]);
+
+export const JsTsSemanticMergeGateStatuses = Object.freeze([
+  'passed',
+  'warning',
+  'failed',
+  'skipped',
+  'blocked'
+]);
+
+import { actionForConflict, actionForGate, array, booleanValue, compactRecord, firstString, normalizeConflictSides, normalizeGateChecks, normalizeGateStatus, normalizeRisk, numberValue, readinessForGateStatus, readinessForRisk, strings, titleForConflictClass } from './js-ts-semantic-merge-contract-helpers.js';
+
+export function createJsTsSemanticMergeConflictExplanation(input = {}, options = {}) {
+  const conflictClass = firstString(options.conflictClass, input.conflictClass, input.class, 'same-region-edit');
+  const risk = normalizeRisk(firstString(options.risk, input.risk, input.severity)) ?? 'medium';
+  const readiness = normalizeSemanticMergeReadiness(firstString(options.readiness, input.readiness)) ?? readinessForRisk(risk);
+  const language = firstString(options.language, input.language);
+  const sourcePath = firstString(options.sourcePath, input.sourcePath);
+  const conflictKeys = uniqueStrings([
+    ...strings(input.conflictKeys),
+    input.conflictKey,
+    ...strings(options.conflictKeys),
+    options.conflictKey
+  ]);
+  const matchIds = uniqueStrings([...strings(input.matchIds), ...strings(options.matchIds)]);
+  const editIds = uniqueStrings([...strings(input.editIds), ...strings(options.editIds)]);
+  const regionIds = uniqueStrings([...strings(input.regionIds), ...strings(options.regionIds)]);
+  const tokenIds = uniqueStrings([...strings(input.tokenIds), ...strings(options.tokenIds)]);
+  const triviaIds = uniqueStrings([...strings(input.triviaIds), ...strings(options.triviaIds)]);
+  const evidenceIds = uniqueStrings([...strings(input.evidenceIds), ...strings(options.evidenceIds)]);
+  const reasonCodes = uniqueStrings([
+    ...strings(input.reasonCodes),
+    ...strings(input.reasons),
+    ...strings(options.reasonCodes),
+    `js-ts-conflict:${conflictClass}`
+  ]);
+  const sides = normalizeConflictSides(options.sides ?? input.sides);
+  const title = firstString(options.title, input.title, titleForConflictClass(conflictClass));
+  const summary = firstString(options.summary, input.summary, input.message);
+  const suggestedAction = firstString(options.suggestedAction, input.suggestedAction, actionForConflict({ risk, readiness }));
+  const stablePayload = compactRecord({
+    schema: 'frontier.lang.jsTsSemanticMergeConflictExplanation.v1',
+    conflictClass,
+    risk,
+    readiness,
+    language,
+    sourcePath,
+    title,
+    summary,
+    conflictKeys,
+    matchIds,
+    editIds,
+    regionIds,
+    tokenIds,
+    triviaIds,
+    evidenceIds,
+    reasonCodes,
+    sides,
+    suggestedAction
+  });
+  const hash = hashSemanticValue(stablePayload);
+  const stableId = firstString(options.stableId, input.stableId)
+    || `js_ts_merge_conflict_${idFragment(firstString(conflictKeys[0], sourcePath, conflictClass))}_${idFragment(hash)}`;
+  return compactRecord({
+    kind: 'frontier.lang.jsTsSemanticMergeConflictExplanation',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeConflictExplanation.v1',
+    id: firstString(options.id, input.id, stableId),
+    stableId,
+    hash,
+    conflictClass,
+    risk,
+    readiness,
+    language,
+    sourcePath,
+    title,
+    summary,
+    conflictKeys,
+    matchIds,
+    editIds,
+    regionIds,
+    tokenIds,
+    triviaIds,
+    evidenceIds,
+    reasonCodes,
+    sides,
+    suggestedAction,
+    metadata: compactRecord({
+      normalizedBy: 'frontier-lang-compiler/js-ts-semantic-merge',
+      structuralContract: true,
+      ...(input.metadata ?? {}),
+      ...(options.metadata ?? {})
+    })
+  });
+}
+
+export function createJsTsSemanticMergeGateResult(input = {}, options = {}) {
+  const gateId = firstString(options.gateId, input.gateId, input.id, 'js-ts-semantic-merge');
+  const status = normalizeGateStatus(firstString(options.status, input.status)) ?? 'skipped';
+  const conflicts = [
+    ...array(input.conflictExplanations),
+    ...array(input.conflicts),
+    ...array(options.conflictExplanations),
+    ...array(options.conflicts)
+  ].filter(Boolean).map((conflict) => createJsTsSemanticMergeConflictExplanation(conflict));
+  const conflictExplanationIds = uniqueStrings([
+    ...strings(input.conflictExplanationIds),
+    ...strings(options.conflictExplanationIds),
+    ...conflicts.map((conflict) => conflict.id)
+  ]);
+  const checks = normalizeGateChecks([
+    ...array(input.checks),
+    ...array(options.checks)
+  ], status);
+  const readiness = normalizeSemanticMergeReadiness(firstString(options.readiness, input.readiness)) ?? readinessForGateStatus(status, checks, conflictExplanationIds);
+  const evidenceIds = uniqueStrings([
+    ...strings(input.evidenceIds),
+    ...strings(options.evidenceIds),
+    ...checks.flatMap((check) => strings(check.evidenceIds)),
+    ...conflicts.flatMap((conflict) => conflict.evidenceIds)
+  ]);
+  const reasonCodes = uniqueStrings([
+    ...strings(input.reasonCodes),
+    ...strings(options.reasonCodes),
+    ...checks.flatMap((check) => strings(check.reasonCodes)),
+    ...conflicts.flatMap((conflict) => conflict.reasonCodes),
+    ...(status === 'passed' ? [] : [`js-ts-merge-gate:${status}`])
+  ]);
+  const structuredEditIds = uniqueStrings([
+    ...strings(input.structuredEditIds),
+    ...strings(options.structuredEditIds),
+    ...array(input.structuredEdits).map((edit) => edit?.id),
+    ...array(options.structuredEdits).map((edit) => edit?.id)
+  ]);
+  const semanticRegionIds = uniqueStrings([
+    ...strings(input.semanticRegionIds),
+    ...strings(options.semanticRegionIds),
+    ...array(input.semanticRegions).map((region) => region?.id),
+    ...array(options.semanticRegions).map((region) => region?.id)
+  ]);
+  const mergeable = booleanValue(options.mergeable, input.mergeable)
+    ?? (status === 'passed' && readiness === 'ready' && conflictExplanationIds.length === 0);
+  const action = firstString(options.action, input.action, actionForGate({ status, readiness, mergeable }));
+  const confidence = numberValue(options.confidence, input.confidence, status === 'passed' ? 1 : 0);
+  const failedChecks = checks.filter((check) => check.status === 'failed').length;
+  const warningChecks = checks.filter((check) => check.status === 'warning').length;
+  const blockedChecks = checks.filter((check) => check.status === 'blocked').length;
+  const summary = {
+    checks: checks.length,
+    conflicts: conflictExplanationIds.length,
+    failedChecks,
+    warningChecks,
+    blockedChecks,
+    evidenceIds: evidenceIds.length,
+    reasonCodes
+  };
+  const stablePayload = compactRecord({
+    schema: 'frontier.lang.jsTsSemanticMergeGateResult.v1',
+    gateId,
+    status,
+    readiness,
+    mergeable,
+    action,
+    confidence,
+    checks,
+    conflictExplanationIds,
+    structuredEditIds,
+    semanticRegionIds,
+    evidenceIds,
+    reasonCodes,
+    summary
+  });
+  const hash = hashSemanticValue(stablePayload);
+  const stableId = firstString(options.stableId, input.stableId)
+    || `js_ts_merge_gate_${idFragment(gateId)}_${idFragment(hash)}`;
+  return compactRecord({
+    kind: 'frontier.lang.jsTsSemanticMergeGateResult',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeGateResult.v1',
+    id: firstString(options.id, input.id, stableId),
+    stableId,
+    hash,
+    gateId,
+    status,
+    readiness,
+    mergeable,
+    action,
+    confidence,
+    checks,
+    conflictExplanations: conflicts,
+    conflictExplanationIds,
+    structuredEditIds,
+    semanticRegionIds,
+    evidenceIds,
+    reasonCodes,
+    summary,
+    metadata: compactRecord({
+      normalizedBy: 'frontier-lang-compiler/js-ts-semantic-merge',
+      structuralContract: true,
+      ...(input.metadata ?? {}),
+      ...(options.metadata ?? {})
+    })
+  });
+}

package/dist/js-ts-semantic-merge-member-containers.js

@@ -0,0 +1,100 @@
+function normalizeKind(kind) {
+  const text = String(kind ?? '').toLowerCase();
+  if (text === 'interface') return 'interface';
+  if (text === 'type' || text === 'typealias' || text === 'type-alias') return 'type';
+  if (text === 'class') return 'class';
+  if (text === 'object' || text === 'object-literal') return 'object';
+  return undefined;
+}
+
+function findContainer(sourceText, region) {
+  const kind = normalizeKind(region.kind);
+  const pattern = containerPattern(kind, region.name);
+  const matches = [];
+  let match;
+  while ((match = pattern.exec(sourceText))) {
+    const openIndex = sourceText.indexOf('{', match.index);
+    if (openIndex < 0 || openIndex >= pattern.lastIndex) continue;
+    const closeIndex = findMatchingBrace(sourceText, openIndex);
+    if (closeIndex < 0) return { reasonCodes: ['unterminated-container'] };
+    matches.push({
+      kind,
+      name: region.name,
+      start: match.index,
+      openStart: openIndex,
+      bodyStart: openIndex + 1,
+      bodyEnd: closeIndex,
+      end: closeIndex + 1,
+      body: sourceText.slice(openIndex + 1, closeIndex)
+    });
+  }
+  if (!matches.length) return { reasonCodes: ['container-not-found'] };
+  if (matches.length > 1) return { reasonCodes: ['ambiguous-container'] };
+  return { reasonCodes: [], value: matches[0] };
+}
+
+function containerPattern(kind, name) {
+  const escapedName = escapeRegExp(name);
+  if (kind === 'interface') return new RegExp(`\\b(?:export\\s+)?interface\\s+${escapedName}\\b[^{};=]*\\{`, 'g');
+  if (kind === 'type') return new RegExp(`\\b(?:export\\s+)?type\\s+${escapedName}\\b\\s*=\\s*\\{`, 'g');
+  if (kind === 'class') return new RegExp(`\\b(?:export\\s+)?(?:default\\s+)?(?:abstract\\s+)?class\\s+${escapedName}\\b[^{};=]*\\{`, 'g');
+  return new RegExp(`\\b(?:export\\s+)?(?:const|let|var)\\s+${escapedName}\\b[^=;{}]*=\\s*\\{`, 'g');
+}
+
+function findMatchingBrace(sourceText, openIndex) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  for (let index = openIndex; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export {
+  findContainer,
+  normalizeKind
+};

package/dist/js-ts-semantic-merge-member-keys.js

@@ -0,0 +1,142 @@
+function memberKey(text, kind) {
+  if (kind === 'object') return objectMemberKey(text);
+  if (kind === 'class') return classMemberKey(text);
+  return typeMemberKey(text);
+}
+
+function objectMemberKey(text) {
+  const source = text.replace(/[;,]\s*$/, '').trim();
+  const methodSource = stripObjectMemberPrefixes(source);
+  const methodMatch = methodSource.match(/^(['"]?)([A-Za-z_$][\w$-]*)\1\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: methodMatch[2], memberKind: 'method' };
+  const colon = topLevelColon(text);
+  if (colon >= 0) {
+    const key = propertyKey(text.slice(0, colon).trim());
+    return key ? { key, memberKind: 'property' } : undefined;
+  }
+  const shorthand = propertyKey(source);
+  return shorthand ? { key: shorthand, memberKind: 'property' } : undefined;
+}
+
+function typeMemberKey(text) {
+  const source = text.replace(/[;,]\s*$/, '').trim().replace(/^readonly\s+/, '');
+  const methodMatch = source.match(/^(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: methodMatch[2], memberKind: 'method' };
+  const colon = topLevelColon(source);
+  if (colon < 0) return undefined;
+  const key = propertyKey(source.slice(0, colon).trim().replace(/\?$/, '').trim());
+  return key ? { key, memberKind: 'property' } : undefined;
+}
+
+function classMemberKey(text) {
+  const stripped = stripClassMemberPrefixes(text.replace(/[;,]\s*$/, '').trim());
+  const source = stripped.source;
+  if (!source || source.startsWith('@') || /^static\s*\{/.test(source)) return undefined;
+  const constructorMatch = source.match(/^constructor\s*\(/);
+  if (constructorMatch) return { key: 'constructor', memberKind: 'constructor' };
+  const accessorMatch = source.match(/^(get|set)\s+(['"]?)(#?[A-Za-z_$][\w$-]*)\2\s*\(/);
+  if (accessorMatch) return { key: classMemberKeyName(accessorMatch[3], stripped.isStatic), memberKind: 'accessor' };
+  const methodMatch = source.match(/^(?:async\s+)?(['"]?)(#?[A-Za-z_$][\w$-]*)\1\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: classMemberKeyName(methodMatch[2], stripped.isStatic), memberKind: 'method' };
+  const propertyMatch = source.match(/^(['"]?)(#?[A-Za-z_$][\w$-]*)\1[?!]?\s*(?::|=|$)/);
+  if (propertyMatch) return { key: classMemberKeyName(propertyMatch[2], stripped.isStatic), memberKind: 'property' };
+  return undefined;
+}
+
+function classMemberKeyName(name, isStatic) {
+  return isStatic ? `static.${name}` : name;
+}
+
+function stripObjectMemberPrefixes(source) {
+  return String(source ?? '').replace(/^(?:async|get|set)\s+/, '');
+}
+
+function stripClassMemberPrefixes(source) {
+  let output = String(source ?? '').trim();
+  let isStatic = false;
+  const prefixes = ['public', 'private', 'protected', 'abstract', 'override', 'declare', 'readonly', 'accessor'];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      const pattern = new RegExp(`^${prefix}\\s+`);
+      if (pattern.test(output)) {
+        output = output.replace(pattern, '').trimStart();
+        changed = true;
+      }
+    }
+    if (/^static\s+/.test(output)) {
+      output = output.replace(/^static\s+/, '').trimStart();
+      isStatic = true;
+      changed = true;
+    }
+  }
+  return { source: output, isStatic };
+}
+
+function isTypeAliasConflictMember(text) {
+  return /^\|/.test(text) || /^&/.test(text);
+}
+
+function hasSpreadLikeMember(text) {
+  return stripLeadingMemberKeywords(text).startsWith('...');
+}
+
+function hasComputedMemberKey(text) {
+  return stripLeadingMemberKeywords(text).startsWith('[');
+}
+
+function stripLeadingMemberKeywords(text) {
+  let source = String(text ?? '').trim();
+  const prefixes = ['public', 'private', 'protected', 'abstract', 'override', 'declare', 'readonly', 'static', 'accessor', 'async', 'get', 'set'];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      const pattern = new RegExp(`^${prefix}\\s+`);
+      if (pattern.test(source)) {
+        source = source.replace(pattern, '').trimStart();
+        changed = true;
+      }
+    }
+  }
+  return source;
+}
+
+function propertyKey(source) {
+  if (!source || source.startsWith('[')) return undefined;
+  const quoted = source.match(/^(['"])([^'"\\]+)\1$/);
+  if (quoted) return quoted[2];
+  const identifier = source.match(/^[A-Za-z_$][\w$-]*$/);
+  return identifier?.[0];
+}
+
+function topLevelColon(source) {
+  let quote;
+  let escaped = false;
+  let depth = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') depth += 1;
+    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    else if (char === ':' && depth === 0) return index;
+  }
+  return -1;
+}
+
+export {
+  hasComputedMemberKey,
+  hasSpreadLikeMember,
+  isTypeAliasConflictMember,
+  memberKey
+};

package/dist/js-ts-semantic-merge-member-segments.js

@@ -0,0 +1,185 @@
+import {
+  hasComputedMemberKey,
+  hasSpreadLikeMember,
+  isTypeAliasConflictMember,
+  memberKey
+} from './js-ts-semantic-merge-member-keys.js';
+import { uniqueStrings } from './js-ts-semantic-merge-member-utils.js';
+
+function parseMembers(body, kind) {
+  const reasonCodes = [];
+  const members = [];
+  for (const segment of splitMemberSegments(body, kind)) {
+    const trimmed = segment.text.trim();
+    if (!trimmed) continue;
+    if (hasSpreadLikeMember(trimmed)) {
+      reasonCodes.push('spread-like-member');
+      continue;
+    }
+    if (hasComputedMemberKey(trimmed)) {
+      reasonCodes.push('computed-key');
+      continue;
+    }
+    if (kind === 'type' && isTypeAliasConflictMember(trimmed)) {
+      reasonCodes.push('type-alias-conflict');
+      continue;
+    }
+    const parsed = memberKey(trimmed, kind);
+    if (!parsed?.key) {
+      reasonCodes.push(`unsupported-${kind}-member`);
+      continue;
+    }
+    members.push({ ...segment, ...parsed });
+  }
+  return { members, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function splitMemberSegments(body, kind) {
+  if (kind === 'class') return splitClassMemberSegments(body);
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') depth += 1;
+    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    const separator = kind === 'object' ? ',' : ';';
+    if (char === separator && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function splitClassMemberSegments(body) {
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}' || char === ']' || char === ')') {
+      depth -= 1;
+      if (depth === 0 && char === '}') {
+        const nextIndex = nextSignificantIndex(text, index + 1);
+        if (text[nextIndex] !== ';') {
+          entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+          start = index + 1;
+        }
+      }
+      continue;
+    }
+    if (char === ';' && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function nextSignificantIndex(text, offset) {
+  let index = offset;
+  while (index < text.length) {
+    if (/\s/.test(text[index])) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '/') {
+      index += 2;
+      while (index < text.length && text[index] !== '\n' && text[index] !== '\r') index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '*') {
+      index += 2;
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/')) index += 1;
+      index += 2;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+export {
+  parseMembers
+};