@protontech/autofill 0.0.35059265 → 0.0.36026908

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  ")}`);
     }