@protontech/autofill 0.0.35059265 → 0.0.35481761

package/features/feature.d.ts

@@ -1,6 +1,8 @@
 import type { AbstractFeature, AbstractFeatures, Feature, FeatureComputer, InferFeatureName, InferFeatureReturnType, InferParentComputeType } from "@protontech/autofill/types";
 import type { Fnode } from "@protontech/fathom";
-export declare const feature: <N extends string, R, P extends AbstractFeatures>(name: N, parents: P, compute: (parents: InferParentComputeType<P>, fnode: Fnode) => R) => Feature<N, R, P>;
+export declare const feature: <N extends string, R, P extends AbstractFeatures>(name: N, parents: P, compute: (parents: InferParentComputeType<P>, fnode: Fnode) => R, opts?: {
+    private?: true;
+}) => Feature<N, R, P>;
 export declare const featureCount: <N extends string, R extends unknown[], P extends AbstractFeatures>(feat: Feature<N, R, P>) => Feature<`${N}Count`, number, {
     [x: string]: Feature<N, R, P>;
 }>;
@@ -12,7 +14,16 @@ type FlatFeatures<F extends AbstractFeatures> = {
     [K in keyof F]: FlatFeature<F[K]>;
 };
 export declare const flattenFeatures: <F extends AbstractFeatures>(features: F) => FlatFeatures<F>;
-export declare const getComputerForFeatures: (sorted: readonly AbstractFeature[], outputNames: readonly string[]) => FeatureComputer;
+export declare const getComputerForFeatures: <F extends AbstractFeatures>({ sorted, features, private: privateFeatures }: {
+    sorted: readonly AbstractFeature[];
+    features: readonly string[];
+    private: readonly string[];
+}) => FeatureComputer<FlatFeatures<F>>;
+export declare const validateComputerInputs: ({ sorted, features, private: privateFeatures }: {
+    sorted: readonly AbstractFeature[];
+    features: readonly string[];
+    private: readonly string[];
+}) => void;
 export declare const topologicalSort: (features: AbstractFeatures) => AbstractFeature<unknown>[];
 export declare const computeFeatures: <F extends AbstractFeatures>(featureComputer: FeatureComputer<F>, fnode: Fnode) => import("@protontech/autofill/types").ComputedFeatures<F>;
 export {};

package/features/feature.js

@@ -1,9 +1,10 @@
 import { utils } from "@protontech/fathom";
 const { linearScale } = utils;
-export const feature = (name, parents, compute) => ({
+export const feature = (name, parents, compute, opts) => ({
     name,
     parents,
     compute,
+    ...(opts !== null && opts !== void 0 ? opts : {}),
 });
 export const featureCount = (feat) => feature(`${feat.name}Count`, { [feat.name]: feat }, (parents) => parents[feat.name].length);
 export const featureScaled = (feat, min, max) => feature(`${feat.name}Scaled`, { [feat.name]: feat }, (parents) => linearScale(parents[feat.name], min, max));
@@ -16,17 +17,35 @@ export const featuresProduct = (feat1, feat2) => feature(`${feat1.name},${feat2.
     [feat2.name]: feat2,
 }, (parents) => Number(parents[feat1.name]) * Number(parents[feat2.name]));
 export const flattenFeatures = (features) => features;
-export const getComputerForFeatures = (sorted, outputNames) => {
-    const outputSet = new Set(outputNames);
-    return {
-        compute: (fnode) => {
-            const computed_parents = {};
-            for (const feature of sorted)
-                computed_parents[feature.name] = feature.compute(computed_parents, fnode);
-            return Object.fromEntries(outputNames.map((n) => [n, computed_parents[n]]));
-        },
-        features: sorted.filter((f) => outputSet.has(f.name) && !f.name.startsWith("__")),
-    };
+export const getComputerForFeatures = ({ sorted, features, private: privateFeatures }) => ({
+    compute: (fnode) => {
+        const parents = {};
+        const result = {};
+        for (const feature of sorted)
+            parents[feature.name] = feature.compute(parents, fnode);
+        for (const name of features)
+            result[name] = parents[name];
+        for (const name of privateFeatures)
+            result[name] = parents[name];
+        return result;
+    },
+    features,
+});
+export const validateComputerInputs = ({ sorted, features, private: privateFeatures }) => {
+    const computed = new Set();
+    for (const f of sorted) {
+        if (computed.has(f.name))
+            throw new Error(`duplicate feature '${f.name}' in sorted DAG`);
+        for (const p of Object.values(f.parents)) {
+            if (!computed.has(p.name))
+                throw new Error(`feature '${f.name}' precedes its parent '${p.name}' in sorted DAG`);
+        }
+        computed.add(f.name);
+    }
+    for (const name of [...features, ...privateFeatures]) {
+        if (!computed.has(name))
+            throw new Error(`output '${name}' missing from sorted DAG`);
+    }
 };
 export const topologicalSort = (features) => {
     var _a;
@@ -43,8 +62,10 @@ export const topologicalSort = (features) => {
         else {
             Object.values(node.parents).forEach((parent) => {
                 var _a, _b, _c, _d;
-                if (!seen.has(parent))
+                if (!seen.has(parent)) {
                     to_visit.push(parent);
+                    seen.add(parent);
+                }
                 (_b = (_a = childToParents.get(node)) === null || _a === void 0 ? void 0 : _a.add(parent)) !== null && _b !== void 0 ? _b : childToParents.set(node, new Set([parent]));
                 (_d = (_c = parentToChildren.get(parent)) === null || _c === void 0 ? void 0 : _c.add(node)) !== null && _d !== void 0 ? _d : parentToChildren.set(parent, new Set([node]));
             });
@@ -65,10 +86,11 @@ export const topologicalSort = (features) => {
         sorted.push(node);
     }
     if (childToParents.size > 0) {
-        throw new Error(`loop detected with elements:\n  ${Array.from(childToParents.entries().map(([child, parents]) => `${child.name} -> {${Array.from(parents)
+        throw new Error(`loop detected with elements:\n  ${Array.from(childToParents.entries())
+            .map(([child, parents]) => `${child.name} -> {${Array.from(parents)
             .map((parent) => parent.name)
             .sort()
-            .join(", ")}}`))
+            .join(", ")}}`)
             .sort()
             .join("\n  ")}`);
     }

package/features/feature.spec.js

@@ -1,4 +1,4 @@
-import { feature, featuresProduct, getComputerForFeatures, topologicalSort } from "./feature";
+import { feature, featuresProduct, getComputerForFeatures, topologicalSort, validateComputerInputs } from "./feature";
 function doNothing() {
 }
 describe("topological sort", () => {
@@ -19,6 +19,16 @@ describe("topological sort", () => {
         expect(nodeNames[5]).toEqual("E");
         expect(nodeNames.slice(6, 8).sort()).toEqual(["D", "G"]);
     });
+    test("a node reachable from multiple paths appears only once", () => {
+        const X = feature("X", {}, doNothing);
+        const Y = feature("Y", { X }, doNothing);
+        const A = feature("A", { X, Y }, doNothing);
+        const sorted = topologicalSort({ A });
+        expect(sorted.length).toBe(new Set(sorted).size);
+        const pos = new Map(sorted.map((f, i) => [f, i]));
+        expect(pos.get(X)).toBeLessThan(pos.get(Y));
+        expect(pos.get(Y)).toBeLessThan(pos.get(A));
+    });
     test("it fails if there is a loop", () => {
         const A = feature("A", {}, doNothing);
         const B = feature("B", { A }, doNothing);
@@ -39,21 +49,60 @@ describe("topological sort", () => {
   G -> {E}`);
     });
 });
+const buildComputer = (outputs) => getComputerForFeatures({
+    sorted: topologicalSort(outputs),
+    features: Object.values(outputs)
+        .filter((f) => !f.private)
+        .map((f) => f.name),
+    private: Object.values(outputs)
+        .filter((f) => f.private)
+        .map((f) => f.name),
+});
 describe("Feature engineering", () => {
     test("featureProduct", () => {
         const A = feature("A", {}, () => 2);
         const B = feature("B", { A }, () => 4);
         const C = featuresProduct(A, B);
-        const features = { A, B, C };
-        const outputNames = Object.values(features).map((f) => f.name);
-        expect(getComputerForFeatures(topologicalSort(features), outputNames).compute({})).toStrictEqual({ A: 2, B: 4, "A,B": 8 });
+        expect(buildComputer({ A, B, C }).compute({})).toMatchObject({ A: 2, B: 4, "A,B": 8 });
     });
     test("feature name re-mapping", () => {
         const A = feature("A", {}, () => 2);
         const B = feature("_B", { A }, () => 4);
         const C = feature("C", { A, B }, (p) => p.A + p._B);
-        const features = { A, B, C };
-        const outputNames = Object.values(features).map((f) => f.name);
-        expect(getComputerForFeatures(topologicalSort(features), outputNames).compute({})).toStrictEqual({ A: 2, _B: 4, C: 6 });
+        expect(buildComputer({ A, B, C }).compute({})).toMatchObject({ A: 2, _B: 4, C: 6 });
+    });
+    describe("validateComputerInputs (gen-time guards)", () => {
+        const A = feature("A", {}, () => 1);
+        const B = feature("B", { A }, () => 2);
+        test("throws on a duplicate feature name in sorted", () => {
+            const Adup = feature("A", {}, () => 9);
+            expect(() => validateComputerInputs({ sorted: [A, Adup], features: ["A"], private: [] })).toThrow("duplicate feature 'A' in sorted DAG");
+        });
+        test("throws when a parent is ordered after its child", () => {
+            expect(() => validateComputerInputs({ sorted: [B, A], features: ["A", "B"], private: [] })).toThrow("feature 'B' precedes its parent 'A' in sorted DAG");
+        });
+        test("throws when an output name is absent from the DAG", () => {
+            expect(() => validateComputerInputs({ sorted: [A], features: ["A", "ghost"], private: [] })).toThrow("output 'ghost' missing from sorted DAG");
+            expect(() => validateComputerInputs({ sorted: [A], features: ["A"], private: ["secret"] })).toThrow("output 'secret' missing from sorted DAG");
+        });
+        test("accepts a well-formed, topologically sorted DAG", () => {
+            expect(() => validateComputerInputs({ sorted: [A, B], features: ["A", "B"], private: [] })).not.toThrow();
+        });
+    });
+    describe("private outputs", () => {
+        const Trans = feature("Trans", {}, () => 10);
+        const Priv = feature("Priv", { Trans }, (p) => p.Trans + 1, { private: true });
+        const Pub = feature("Pub", { Priv }, (p) => p.Priv + 1);
+        const computer = buildComputer({ Pub, Priv });
+        const result = computer.compute({});
+        test(".features lists only non-private outputs", () => {
+            expect(computer.features).toEqual(["Pub"]);
+        });
+        test("compute() result includes private outputs ", () => {
+            expect(result).toEqual({ Pub: 12, Priv: 11 });
+        });
+        test("compute() result excludes transients ", () => {
+            expect(result).not.toHaveProperty("Trans");
+        });
     });
 });