j-templates 8.0.14 → 8.0.16

package/Store/Diff/diffTree.d.ts

@@ -39,7 +39,7 @@ export interface IDiffTreeConstructor {
  * positionally in the same order, so each parameter can be typed at the call site instead of
  * cast out of a generic read.
  */
-export type DiffTreeProjectionFunc = (...values: any[]) => any;
+export type DiffTreeProjectionFunc = (keys: string[], ...values: any[]) => any;
 /**
  * A projection's declaration: the dot-separated paths it reads (a plain tree path, an
  * entity's key, or another projection's `$projection_<id>` key for chaining) and the

package/Store/Diff/diffTree.js

@@ -160,7 +160,14 @@ function BuildProjectionOrder(projections) {
             throw new Error(`DiffTree projection "${id}" is not defined`);
         state.set(id, "visiting");
         for (let x = 0; x < def.reads.length; x++) {
-            const root = def.reads[x].split(".", 1)[0];
+            const read = def.reads[x];
+            const root = read.split(".", 1)[0];
+            if (root.endsWith("*") && x !== def.reads.length - 1)
+                throw `Wildcard reads only supported as the final read: ${root}`;
+            if (root.endsWith("*") && root.includes("."))
+                throw `Wildcard reads do not support dot nesting: ${root}`;
+            if (root.startsWith(PROJECTION_PREFIX) && read.endsWith("*"))
+                throw `Projection keys do not support wildcard reads: ${root}`;
             if (root.startsWith(PROJECTION_PREFIX))
                 Visit(root.slice(PROJECTION_PREFIX.length), stack.concat(id));
         }
@@ -203,17 +210,31 @@ function RunProjections(source, keyFunc, projections, memo) {
     const diffResult = [];
     for (let x = 0; x < projections.length; x++) {
         const { id, reads, projection } = projections[x];
-        const values = new Array(reads.length);
+        const values = [];
+        const keys = [];
         let allPathsExist = true;
-        for (let y = 0; allPathsExist && y < reads.length; y++) {
-            const [value, found] = GetPathValue(source, reads[y]);
+        let y = 0;
+        for (; allPathsExist && y < reads.length && !reads[y].endsWith("*"); y++) {
+            const read = reads[y];
+            const [value, found] = GetPathValue(source, read);
             allPathsExist = found;
-            values[y] = (found && CreateSnapshot(source, keyFunc, value)) || value;
+            keys.push(read);
+            values.push((found && CreateSnapshot(source, keyFunc, value)) || value);
+        }
+        if (y < reads.length && reads[y].endsWith("*")) {
+            const prefix = reads[y].slice(0, reads[y].length - 1);
+            const matchedKeys = Object.keys(source).filter(key => key.startsWith(prefix));
+            for (let z = 0; z < matchedKeys.length; z++) {
+                const [value, found] = GetPathValue(source, matchedKeys[z]);
+                allPathsExist = allPathsExist && found;
+                keys.push(matchedKeys[z]);
+                values.push((found && CreateSnapshot(source, keyFunc, value)) || value);
+            }
         }
         if (allPathsExist) {
             const priorValues = memo.get(id);
             if (!ArraysEqual(priorValues, values)) {
-                const result = projection(...values);
+                const result = projection(keys, ...values);
                 memo.set(id, values);
                 // The same diff-and-apply UpdateSource uses for any other write, so a keyed entity
                 // embedded in a projection's result is flattened to its own root like any other write,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "8.0.14",
+  "version": "8.0.16",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",