@shapeshift-labs/frontier-lang-css 0.1.8 → 0.1.9

package/dist/index.d.ts

@@ -235,9 +235,7 @@ export interface CssSemanticMergeEvidence {
 }
 
 export interface CssSafeMergeConflict {
-  readonly code: string;
-  readonly gateId: 'css-semantic-merge' | string;
-  readonly sourcePath?: string;
+  readonly code: string; readonly gateId: 'css-semantic-merge' | string; readonly sourcePath?: string;
   readonly details: Readonly<Record<string, unknown>> & { readonly reasonCode: string; readonly conflictKey: string };
 }
 
@@ -262,22 +260,20 @@ export interface CssSafeMergeResult {
 export interface CssSafeMergeParserEvidence {
   readonly kind: 'frontier.lang.cssSafeMergeParserEvidence'; readonly version: 1; readonly parserNames: readonly string[];
   readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
-  readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number;
-  readonly sides: Readonly<Record<string, CssSafeMergeParserSideEvidence>>;
+  readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly sides: Readonly<Record<string, CssSafeMergeParserSideEvidence>>;
 }
 
 export interface CssSafeMergeParserSideEvidence {
-  readonly parserName: string;
-  readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
+  readonly parserName: string; readonly sourceCodeLocationInfo: boolean; readonly parserBackedSourceSpans: boolean; readonly parserBackedDeclarationSpans: boolean; readonly parserBackedTriviaHashes: boolean;
   readonly scopedCascadeGraphHashPresent: boolean; readonly parseErrors: number; readonly recordCount: number; readonly declarationCount: number;
 }
 
 export interface CssSafeMergeSelectorTargetEvidence {
-  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1;
-  readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
+  readonly kind: 'frontier.lang.cssSafeMergeSelectorTargetEvidence'; readonly version: 1; readonly selectorTargetGraphHashPresent: boolean; readonly parserBackedRuleSpans: boolean;
   readonly selectorMoveCount: number; readonly workerSelectorMoves: number; readonly headSelectorMoves: number;
   readonly sides: Readonly<Record<string, CssSafeMergeSelectorTargetSideEvidence>>;
   readonly moves: Readonly<Record<'worker' | 'head', readonly CssSafeMergeSelectorMove[]>>;
+  readonly rebasedChangeCount?: number; readonly rebaseProofs?: readonly CssSafeMergeSelectorTargetRebaseProof[];
 }
 
 export interface CssSafeMergeSelectorTargetSideEvidence {
@@ -288,7 +284,15 @@ export interface CssSafeMergeSelectorTargetSideEvidence {
 export interface CssSafeMergeSelectorMove {
   readonly side: string; readonly property: string; readonly beforeRuleKey: string; readonly afterRuleKey: string;
   readonly beforeSelectors?: readonly string[]; readonly afterSelectors?: readonly string[]; readonly beforeScopes?: readonly string[]; readonly afterScopes?: readonly string[];
-  readonly declarationHash: string; readonly selectorTargetGraphHashPresent: boolean;
+  readonly declarationHash: string; readonly beforeSelectorTargetGraphHash?: string; readonly afterSelectorTargetGraphHash?: string; readonly selectorTargetGraphHashPresent: boolean;
+}
+
+export interface CssSafeMergeSelectorTargetRebaseProof {
+  readonly kind: 'css-selector-target-rebase'; readonly side: string; readonly fromRuleKey: string; readonly toRuleKey: string; readonly property: string; readonly cascadeKey: string;
+}
+
+export interface CssSelectorTargetEquivalence {
+  readonly fromRuleKey?: string; readonly toRuleKey?: string; readonly fromSelectors?: readonly string[]; readonly toSelectors?: readonly string[]; readonly graphHash?: string;
 }
 
 export interface CssSafeMergeInput {
@@ -296,7 +300,7 @@ export interface CssSafeMergeInput {
   readonly cssModule?: boolean; readonly cssModules?: boolean;
   readonly generatedClassNameMap?: Readonly<Record<string, string>>;
   readonly generatedClassNameMapHash?: string; readonly jsTsUseSiteGraphHash?: string; readonly cssModuleCompositionGraphHash?: string; readonly icssGraphHash?: string; readonly scopedCascadeGraphHash?: string;
-  readonly selectorTargetGraphHash?: string;
+  readonly selectorTargetGraphHash?: string; readonly selectorTargetEquivalences?: readonly CssSelectorTargetEquivalence[];
   readonly baseGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly workerGeneratedClassNameMap?: Readonly<Record<string, string>>; readonly headGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly baseGeneratedClassNameMapHash?: string; readonly workerGeneratedClassNameMapHash?: string; readonly headGeneratedClassNameMapHash?: string;
   readonly baseJsTsUseSiteGraphHash?: string; readonly workerJsTsUseSiteGraphHash?: string; readonly headJsTsUseSiteGraphHash?: string;

package/dist/semantic-merge-selector-targets.js

@@ -46,26 +46,64 @@ function selectorTargetMoves(changes, side) {
       beforeScopes: deletion.before.scopes,
       afterScopes: addition.after.scopes,
       declarationHash: addition.after.declarationHash,
+      beforeSelectorTargetGraphHash: deletion.before.selectorTargetGraphHash,
+      afterSelectorTargetGraphHash: addition.after.selectorTargetGraphHash,
       selectorTargetGraphHashPresent: Boolean(deletion.before.selectorTargetGraphHash && addition.after.selectorTargetGraphHash)
     });
   }
   return moves;
 }
 
-function selectorTargetMoveConflicts(id, sourcePath, selectorTargetEvidence, changed) {
-  return [
-    ...selectorTargetMoveSideConflicts(id, sourcePath, selectorTargetEvidence.moves.worker, selectorTargetEvidence.moves.head, changed.head),
-    ...selectorTargetMoveSideConflicts(id, sourcePath, selectorTargetEvidence.moves.head, selectorTargetEvidence.moves.worker, changed.worker)
-  ];
+function planSelectorTargetRebase(id, sourcePath, selectorTargetEvidence, changed, options = {}) {
+  const planned = { worker: [...changed.worker], head: [...changed.head] };
+  const worker = selectorTargetMoveSidePlan(id, sourcePath, selectorTargetEvidence.moves.worker, selectorTargetEvidence.moves.head, planned.head, options);
+  const head = selectorTargetMoveSidePlan(id, sourcePath, selectorTargetEvidence.moves.head, selectorTargetEvidence.moves.worker, planned.worker, options);
+  return {
+    changed: planned,
+    conflicts: [...worker.conflicts, ...head.conflicts],
+    evidence: { ...selectorTargetEvidence, rebasedChangeCount: worker.rebaseProofs.length + head.rebaseProofs.length, rebaseProofs: [...worker.rebaseProofs, ...head.rebaseProofs] }
+  };
+}
+
+function selectorTargetMoveSidePlan(id, sourcePath, moves, oppositeMoves, oppositeChanges, options) {
+  const conflicts = [];
+  const rebaseProofs = [];
+  for (const move of moves) {
+    if (oppositeMoves.some((oppositeMove) => sameSelectorMove(move, oppositeMove))) continue;
+    for (let index = 0; index < oppositeChanges.length; index += 1) {
+      const change = oppositeChanges[index];
+      if (!selectorMoveTouchesChange(move, change)) continue;
+      if (canRebaseChange(move, change, options)) {
+        const rebased = rebaseChangeToSelectorMove(change, move);
+        oppositeChanges[index] = rebased.change;
+        rebaseProofs.push(rebased.proof);
+      } else conflicts.push(conflict(id, sourcePath, change.key, move, change));
+    }
+  }
+  return { conflicts, rebaseProofs };
 }
 
-function selectorTargetMoveSideConflicts(id, sourcePath, moves, oppositeMoves, oppositeChanges) {
-  return moves.flatMap((move) => {
-    if (oppositeMoves.some((oppositeMove) => sameSelectorMove(move, oppositeMove))) return [];
-    return oppositeChanges.filter((change) => selectorMoveTouchesChange(move, change)).map((change) => conflict(id, sourcePath, change.key, move, change));
+function canRebaseChange(move, change, options) {
+  return change.kind === 'add' && change.after && hasSelectorTargetEquivalence(move, options);
+}
+
+function hasSelectorTargetEquivalence(move, options) {
+  return (options.selectorTargetEquivalences ?? []).some((entry) => {
+    const ruleKeysMatch = entry.fromRuleKey === move.beforeRuleKey && entry.toRuleKey === move.afterRuleKey;
+    const selectorsMatch = selectorListKey(entry.fromSelectors) === selectorListKey(move.beforeSelectors) && selectorListKey(entry.toSelectors) === selectorListKey(move.afterSelectors);
+    const graphMatches = !entry.graphHash || entry.graphHash === move.beforeSelectorTargetGraphHash || entry.graphHash === move.afterSelectorTargetGraphHash;
+    return graphMatches && (ruleKeysMatch || selectorsMatch);
   });
 }
 
+function rebaseChangeToSelectorMove(change, move) {
+  const after = { ...change.after, ruleKey: move.afterRuleKey, selectors: move.afterSelectors, scopes: move.afterScopes ?? [], key: cascadeKey(move.afterScopes, move.afterSelectors, change.after.property), rebasedFromRuleKey: move.beforeRuleKey };
+  return {
+    change: { ...change, key: after.key, after },
+    proof: { kind: 'css-selector-target-rebase', side: change.side, fromRuleKey: move.beforeRuleKey, toRuleKey: move.afterRuleKey, property: change.after.property, cascadeKey: after.key }
+  };
+}
+
 function conflict(id, sourcePath, cascadeKey, selectorMove, change) {
   return {
     code: 'css-selector-target-conflict',
@@ -94,6 +132,8 @@ function sameSelectorMove(left, right) {
   return left.property === right.property && left.beforeRuleKey === right.beforeRuleKey && left.afterRuleKey === right.afterRuleKey && left.declarationHash === right.declarationHash;
 }
 
+function cascadeKey(scopes = [], selectors = [], property) { return [...scopes, selectors.join(','), property].join('::'); }
+function selectorListKey(value = []) { return Array.isArray(value) ? value.join(',') : undefined; }
 function changeDetails(change) { return { kind: change.kind, property: (change.after ?? change.before)?.property, value: change.after?.value, important: change.after?.important }; }
 
-export { mergeSelectorTargetEvidence, selectorTargetMoveConflicts };
+export { mergeSelectorTargetEvidence, planSelectorTargetRebase };

package/dist/semantic-merge.js

@@ -1,5 +1,5 @@
 import { cssModuleContractChanges, cssModuleContractConflicts, sheetOptions, unsupportedSourceShapeConflicts } from './semantic-merge-css-modules.js';
-import { mergeSelectorTargetEvidence, selectorTargetMoveConflicts } from './semantic-merge-selector-targets.js';
+import { mergeSelectorTargetEvidence, planSelectorTargetRebase } from './semantic-merge-selector-targets.js';
 
 function safeMergeCssSource(input = {}, context = {}) {
   const parseSheet = context.parseCssSemanticSheet;
@@ -31,11 +31,10 @@ function safeMergeCssSource(input = {}, context = {}) {
   const moduleConflicts = cssModuleContractConflicts(id, sourcePath, moduleChanges);
   const sourceShapeConflicts = unsupportedSourceShapeConflicts(id, sourcePath, sheets, changed, hash);
   const parserEvidence = mergeParserEvidence(sheets);
-  const selectorTargetEvidence = mergeSelectorTargetEvidence(sheets, changed);
-  const selectorTargetConflicts = selectorTargetMoveConflicts(id, sourcePath, selectorTargetEvidence, changed);
-  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...sourceShapeConflicts, ...selectorTargetConflicts];
-  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, selectorTargetEvidence });
-  const mergedIndex = applyDeclarationChanges(applyDeclarationChanges(indexes.base, changed.head), changed.worker);
+  const selectorTargetPlan = planSelectorTargetRebase(id, sourcePath, mergeSelectorTargetEvidence(sheets, changed), changed, input);
+  const conflicts = [...parserConflicts, ...proofConflicts, ...overlapConflicts, ...moduleConflicts, ...sourceShapeConflicts, ...selectorTargetPlan.conflicts];
+  if (conflicts.length) return blocked(id, sourcePath, 'css-semantic-merge-conflict', conflicts, { parserEvidence, selectorTargetEvidence: selectorTargetPlan.evidence });
+  const mergedIndex = applyDeclarationChanges(applyDeclarationChanges(indexes.base, selectorTargetPlan.changed.head), selectorTargetPlan.changed.worker);
   return merged(id, sourcePath, renderDeclarationIndex(mergedIndex), 'semantic-declaration-merge', hash, {
     baseSheetHash: sheets.base.sheetHash,
     workerSheetHash: sheets.worker.sheetHash,
@@ -45,7 +44,7 @@ function safeMergeCssSource(input = {}, context = {}) {
     workerChangedCssModuleContracts: moduleChanges.worker.length,
     headChangedCssModuleContracts: moduleChanges.head.length,
     parserEvidence,
-    selectorTargetEvidence
+    selectorTargetEvidence: selectorTargetPlan.evidence
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-css",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "CSS semantic merge evidence and projection adapter for Frontier Lang semantic source documents.",
   "type": "module",
   "main": "./dist/index.js",