@gesslar/sassy 3.0.0 → 3.2.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.0.0",
+  "version": "3.2.0",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/sassy#readme",
   "repository": {

package/src/Compiler.js

@@ -117,7 +117,7 @@ export default class Compiler {
       // Assemble into one object with the proper keys
       const colors = workColors.reduce(reducer, {})
       const tokenColors = this.#composeArray(workTokenColors)
-      const semanticTokenColors = workSemanticTokenColors.reduce(reducer, {})
+      const semanticTokenColors = this.#composeObject(workSemanticTokenColors)
 
       // Mix and maaatch all jumbly wumbly...
       const output = Data.mergeObject(

package/src/ResolveCommand.js

@@ -176,11 +176,35 @@ export default class ResolveCommand extends Command {
     const matches = this.#findScopeMatches(tokenColors, scopeName)
 
     if(matches.length === 0) {
+      // Try precedence-based fallback
+      const precedenceMatch = this.#findBestPrecedenceMatch(tokenColors, scopeName)
+
+      if(precedenceMatch) {
+        await this.#resolveScopeMatch(
+          theme, precedenceMatch.entry, scopeName,
+          {scope: precedenceMatch.matchedScope, relation: "via"}
+        )
+
+        return
+      }
+
       return Term.info(`No tokenColors entries found for scope '${scopeName}'`)
     }
 
     if(matches.length === 1) {
-      // Single match - resolve directly
+      // Check if a broader scope earlier in the array masks this exact match
+      const maskingScope = this.#findMaskingScope(tokenColors, matches[0], scopeName)
+
+      if(maskingScope) {
+        await this.#resolveScopeMatch(
+          theme, maskingScope.entry, scopeName,
+          {scope: maskingScope.matchedScope, relation: "masked by"}
+        )
+
+        return
+      }
+
+      // No masking - resolve directly
       await this.#resolveScopeMatch(theme, matches[0], scopeName)
     } else {
       // Multiple matches - show disambiguation options
@@ -205,7 +229,94 @@ export default class ResolveCommand extends Command {
     })
   }
 
-  async #resolveScopeMatch(theme, match, displayName) {
+  /**
+   * Finds the best precedence match for a target scope that has no exact match.
+   * Uses TextMate scope hierarchy rules: a broader scope (fewer segments) that
+   * is a prefix of the target scope will match. Returns the most specific
+   * (longest) broader scope.
+   *
+   * @param {Array} tokenColors - Array of tokenColors entries
+   * @param {string} targetScope - The scope to find a precedence match for
+   * @returns {{entry: object, matchedScope: string}|null} The best match or null
+   * @private
+   */
+  #findBestPrecedenceMatch(tokenColors, targetScope) {
+    const targetSegments = targetScope.split(".")
+    let bestMatch = null
+    let bestLength = 0
+
+    for(const entry of tokenColors) {
+      if(!entry.scope)
+        continue
+
+      const scopes = entry.scope.split(",").map(s => s.trim())
+
+      for(const scope of scopes) {
+        const scopeSegments = scope.split(".")
+
+        // Must be fewer segments (broader) and a prefix of the target
+        if(scopeSegments.length >= targetSegments.length)
+          continue
+
+        const isPrefix = scopeSegments.every((seg, i) =>
+          seg === targetSegments[i]
+        )
+
+        if(isPrefix && scopeSegments.length > bestLength) {
+          bestLength = scopeSegments.length
+          bestMatch = {entry, matchedScope: scope}
+        }
+      }
+    }
+
+    return bestMatch
+  }
+
+  /**
+   * Finds a broader scope that appears earlier in the tokenColors array
+   * and would mask the given exact match entry.
+   *
+   * @param {Array} tokenColors - Array of tokenColors entries
+   * @param {object} exactMatch - The exact match entry
+   * @param {string} targetScope - The scope being resolved
+   * @returns {{entry: object, matchedScope: string}|null} The masking entry or null
+   * @private
+   */
+  #findMaskingScope(tokenColors, exactMatch, targetScope) {
+    const targetSegments = targetScope.split(".")
+    const exactIndex = tokenColors.indexOf(exactMatch)
+    let bestMatch = null
+    let bestLength = 0
+
+    for(let i = 0; i < exactIndex; i++) {
+      const entry = tokenColors[i]
+
+      if(!entry.scope)
+        continue
+
+      const scopes = entry.scope.split(",").map(s => s.trim())
+
+      for(const scope of scopes) {
+        const scopeSegments = scope.split(".")
+
+        if(scopeSegments.length >= targetSegments.length)
+          continue
+
+        const isPrefix = scopeSegments.every((seg, idx) =>
+          seg === targetSegments[idx]
+        )
+
+        if(isPrefix && scopeSegments.length > bestLength) {
+          bestLength = scopeSegments.length
+          bestMatch = {entry, matchedScope: scope}
+        }
+      }
+    }
+
+    return bestMatch
+  }
+
+  async #resolveScopeMatch(theme, match, displayName, resolvedVia = null) {
     const pool = theme.getPool()
     const settings = match.settings || {}
     const name = match.name || "Unnamed"
@@ -255,9 +366,13 @@ export default class ResolveCommand extends Command {
     const fullTrail = this.#buildCompleteTrail(bestToken, trail)
     const finalValue = bestToken.getValue()
     const [formattedFinalValue] = this.#formatLeaf(finalValue)
-    const output = c`{head}${displayName}{/} {hex}${(`${name}`)}{/}\n`+
-                    `${this.#formatOutput(fullTrail)}\n\n{head}`+
-                    `${"Resolution:"}{/} ${formattedFinalValue}`
+    const header = resolvedVia
+      ? c`{<BU}${displayName}{/} {<I}${resolvedVia.relation}{/} {<BU}${resolvedVia.scope}{/} {<I}in{/} {hex}${(`${name}`)}{/}\n`
+      : c`{<BU}${displayName}{/} {<I}in{/} {hex}${(`${name}`)}{/}\n`
+
+    const output = header +
+                    `${this.#formatOutput(fullTrail)}\n\n`+
+                    c`{head}${"Resolution:"}{/} ${formattedFinalValue}`
 
     Term.info(output)
   }