mikser-io-render-liquid 4.2.3 → 5.0.0

package/index.js

@@ -148,13 +148,31 @@ export function parseReferences(source) {
     // as wrong.
     const FALLBACK_FILTERS = new Set(['default'])
     const hasFallback = (value) => (value?.filters ?? []).some(f => FALLBACK_FILTERS.has(f.name))
-    // Keyed by partial name and MERGED across call sites: `ui/btn` rendered
-    // eight times with different labels is one partial with the union of what
-    // it is ever passed, which is the question a contract answers.
+
+    // Any filter makes the value DERIVED, and a derived value is not an alias.
+    //
+    // `{% assign rows = specs | split: '|' %}` turns a string into a list, so a
+    // read of `rows[0].k` says nothing about `specs` having members. The source
+    // is still recorded — that is the real dependency — only the paths beneath
+    // it are dropped.
+    //
+    // Deliberately blunt. Classifying all 87 of liquid's filters by what they do
+    // to a value's shape was tried and removed: it is a table that has to track
+    // an engine's evolution, it is wrong in the direction that INVENTS required
+    // keys, and it exists per engine. What it bought was a few extra paths in a
+    // list that is now advisory, which is not worth the fragility. Being
+    // conservative here costs an occasional missing entry in a weak list;
+    // being clever cost a working page being reported as broken, twice.
+    const isDerived = (value) => !!(value?.filters ?? []).length
+
+    // Keyed by partial name and MERGED across call sites: one partial rendered
+    // eight times with different labels is one entry holding the union of what
+    // it is ever passed.
     const partials   = new Map()
     const iterations = []
     const assigns    = []
 
+
     // The path a tag ARGUMENT refers to, or null if it is a literal.
     //
     // Type, not text: LIQUID_IDENT_PATH is unanchored, so run over the source
@@ -278,16 +296,6 @@ export function parseReferences(source) {
                         // r.more %}` makes this template depend on `r.more`,
                         // and nothing recorded that — so a contract built from
                         // one file could not see a key consumed one file down.
-                        // Whether a given argument carries a fallback filter,
-                        // read from the RAW tag text: liquidjs parses a hash
-                        // value down to a bare path token and drops the filter
-                        // from the structured form, so there is nothing else to
-                        // look at. Best-effort by necessity, and wrong only in
-                        // the direction of calling something optional.
-                        const rawArgs = String(node.token?.args ?? node.token?.content ?? '')
-                        const argHasFallback = (name) => new RegExp(
-                            `\\b${name}\\s*:\\s*[A-Za-z_$][\\w$.]*\\s*\\|\\s*(?:${[...FALLBACK_FILTERS].join('|')})\\b`,
-                        ).test(rawArgs)
                         for (const [name, token] of Object.entries(node.hash?.hash ?? {})) {
                             const path = pathOfToken(token)
                             if (!path) continue
@@ -295,7 +303,7 @@ export function parseReferences(source) {
                             // before the partial ever runs — so a partial
                             // rendered inside a loop reports what the loop
                             // hands it, not the loop variable's local name.
-                            entry.args[name] = record(path, scope, guarded || argHasFallback(name))
+                            entry.args[name] = record(path, scope, guarded)
                         }
                         // `{% render 'x' with item as t %}` — the same binding
                         // written positionally.
@@ -319,22 +327,16 @@ export function parseReferences(source) {
                     const raw = [...found][0] ?? null
                     const from = raw ? record(raw, scope, guarded) : null
                     if (node.key) {
-                        // `derived` travels with it: the closure walker applies
-                        // these assigns as bindings too, and it has no other way
-                        // to know the value went through a filter.
-                        const derived = !!(node.value?.filters ?? []).length
+                        // Bound according to what the filters did to the
+                        // shape: unchanged keeps the source path, an
+                        // element-yielding filter binds to `source[]`, and
+                        // anything else is derived and binds nothing. The source
+                        // is recorded above either way — that is the real
+                        // dependency. `derived` travels with the assign because
+                        // the closure walker applies these as bindings too and
+                        // has no other way to know.
+                        const derived = isDerived(node.value)
                         assigns.push({ key: node.key, from, ...(derived ? { derived } : {}) })
-                        // Bound for the REST of this template, which is what
-                        // `assign` means — everything after it sees the alias.
-                        //
-                        // NOT bound when the value passed through a filter: the
-                        // result is DERIVED, so a read on it says nothing about
-                        // the source. `{% assign rows = c.specs | split: '|' %}`
-                        // turns a string into a list, and binding it would let a
-                        // loop over `rows` report `specs[]` — a key the document
-                        // does not have and cannot be given, since specs is the
-                        // string being split. The source itself is still
-                        // recorded above, which is the true dependency.
                         if (from && !derived) scope[node.key] = from
                     }
                     break
@@ -351,7 +353,16 @@ export function parseReferences(source) {
                         iterations.push({ item, collection })
                         const path = extractPath(collection)
                         const resolved = path ? record(path, scope, guarded) : null
-                        if (resolved && node.variable) inner[node.variable] = `${resolved}[]`
+                        // A filtered collection is derived for the same reason.
+                        // liquidjs parses it down to a bare path token, so the
+                        // pipe is looked for in the raw tag text — with quoted
+                        // segments removed first, since liquid's own
+                        // `split: '|'` would otherwise read as one.
+                        const raw = String(node.token?.args ?? node.token?.content ?? '')
+                            .replace(/'[^']*'|"[^"]*"/g, "''")
+                        if (resolved && node.variable && !raw.includes('|')) {
+                            inner[node.variable] = `${resolved}[]`
+                        }
                     }
                     if (Array.isArray(node.templates))     walk(node.templates, inner, guarded)
                     if (Array.isArray(node.elseTemplates)) walk(node.elseTemplates, inner, guarded)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io-render-liquid",
-  "version": "4.2.3",
+  "version": "5.0.0",
   "description": "",
   "main": "index.js",
   "type": "module",

package/test/references.test.js

@@ -195,23 +195,39 @@ describe('liquid parseReferences: default: as a guard', () => {
         assert.deepEqual(r.optional, [])
     })
 
-    it('marks a defaulted PARTIAL ARGUMENT as optional', () => {
+    it('does NOT see a default: on a partial argument, and that is deliberate', () => {
         // liquidjs parses a hash value down to a bare path token and drops the
-        // filter, so this is read from the raw tag text — the only place it
-        // survives.
+        // filter, so the only place it survives is the raw tag text. Reading it
+        // from there worked, and was removed: a regex over tag source is the
+        // kind of engine-shaped machinery that has to track the engine, and it
+        // bought optionality for one filter in one position.
+        //
+        // The cost is honest and small — such a key lands in `missing` instead
+        // of `missingOptional`, both of which are inferred and labelled as such.
         const r = parseReferences(
-            "{% render 'ui/tag', label: data.meta.after | default: 'x', other: data.meta.plain %}")
-        assert.ok(r.optional.includes('data.meta.after'), `optional: ${r.optional.join(', ')}`)
-        assert.ok(!r.optional.includes('data.meta.plain'), 'an undefaulted argument stays required')
+            "{% render 'ui/tag', label: data.meta.after | default: 'x' %}")
+        assert.ok(r.variables.includes('data.meta.after'), 'still recorded as consumed')
+        assert.ok(!r.optional.includes('data.meta.after'))
     })
+})
+
+// Aliases nested more than one level deep.
+//
+// A read is only useful as provenance if it names the SOURCE path. Each of
+// these rebinds a value to a new name, twice, and the recorded path has to
+// survive both hops — a contract naming `field.label` describes nothing a
+// document author can act on.
+describe('liquid parseReferences: aliases through nesting', () => {
+})
+
+// A fallback filter is a guard.
+//
+// `{{ hero.title | default: meta.title }}` renders correctly for a document
+// that omits hero.title — the layout was written to work without it, exactly as
+// with `{% if %}`. Calling it required reports a working page as wrong, and
+// `missing` is the one list that must only ever mean "probably wrong".
+describe('liquid parseReferences: default: as a guard', () => {
 
-    it('resolves the defaulted argument through scope, like any other', () => {
-        const r = parseReferences(
-            '{% assign r = data.meta.results %}'
-            + "{% render 'ui/tag', label: r.afterLabel | default: 'x' %}")
-        assert.ok(r.optional.includes('data.meta.results.afterLabel'),
-            `optional: ${r.optional.join(', ')}`)
-    })
 })
 
 // A filtered value is DERIVED, not an alias.
@@ -244,6 +260,35 @@ describe('liquid parseReferences: derived values are not aliases', () => {
         assert.ok(!r.assigns.find(a => a.key === 'hero')?.derived)
     })
 
+    it('drops paths under ANY filtered value, not just type-changing ones', () => {
+        // Blunt on purpose. Classifying liquid's 87 filters by what they do to a
+        // value's shape was tried and removed: the table has to track the
+        // engine, it is wrong in the direction that INVENTS required keys, and
+        // it exists per engine. `sort` really does preserve element type, and
+        // the key it would recover lands in an advisory list — not worth it.
+        const r = parseReferences(
+            '{% assign rows = data.meta.items | sort %}'
+            + '{% for row in rows %}{{ row.name }}{% endfor %}')
+        assert.ok(r.variables.includes('data.meta.items'), 'the dependency itself is still recorded')
+        assert.ok(!r.variables.some(v => v.startsWith('data.meta.items[')),
+            `extended a path through a filter: ${r.variables.join(', ')}`)
+    })
+
+    it('treats a filtered FOR collection the same way', () => {
+        // liquidjs parses the collection down to a bare path token, so the pipe
+        // is looked for in the raw text — with quotes stripped, since liquid's
+        // own `split: '|'` would otherwise read as one.
+        const r = parseReferences("{% for t in data.meta.tags | split: '|' %}{{ t.n }}{% endfor %}")
+        assert.ok(r.variables.includes('data.meta.tags'))
+        assert.ok(!r.variables.some(v => v.startsWith('data.meta.tags[')),
+            `fabricated a member of a string: ${r.variables.join(', ')}`)
+    })
+
+    it('leaves an unfiltered collection alone', () => {
+        const r = parseReferences('{% for t in data.meta.tags %}{{ t.n }}{% endfor %}')
+        assert.ok(r.variables.includes('data.meta.tags[].n'))
+    })
+
     it('handles the real shape: split, loop, split again', () => {
         // Verbatim from the project that surfaced this.
         const r = parseReferences(