@protontech/autofill 0.0.33835493 → 0.0.35481761

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@protontech/autofill",
-  "version": "0.0.33835493",
+  "version": "0.0.35481761",
   "private": false,
   "scripts": {
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@protontech/fathom": "0.0.33835493",
-    "@protontech/ml-inference": "0.0.33835493"
+    "@protontech/fathom": "0.0.35481761",
+    "@protontech/ml-inference": "0.0.35481761"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/rules/v1/index.js

@@ -12,12 +12,12 @@ import { isVisibleForm } from "@protontech/autofill/utils/visible";
 import { dom, out, rule, type } from "@protontech/fathom";
 const getRulesForFieldClass = (klass, featureComputer) => [
     rule(type(`${klass}-field`), type(klass), {}),
-    ...featureComputer.features.map((feat) => rule(type(klass), featureScore(`${klass}-field`, feat), { name: `${klass}${FEATURE_SEPARATOR}${feat.name}` })),
+    ...featureComputer.features.map((featName) => rule(type(klass), featureScore(`${klass}-field`, featName), { name: `${klass}${FEATURE_SEPARATOR}${featName}` })),
     ...outRuleWithCache("field-candidate", klass),
 ];
 const getRulesForFormClass = (klass, featureComputer) => [
     rule(type("form"), type(klass), {}),
-    ...featureComputer.features.map((feat) => rule(type(klass), featureScore("form", feat), { name: `${klass}${FEATURE_SEPARATOR}${feat.name}` })),
+    ...featureComputer.features.map((featName) => rule(type(klass), featureScore("form", featName), { name: `${klass}${FEATURE_SEPARATOR}${featName}` })),
     ...outRuleWithCache("form-candidate", klass),
 ];
 const noopRules = [

package/scripts/gen-sorted-features.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/gen-sorted-features.js

@@ -0,0 +1,128 @@
+import { topologicalSort, validateComputerInputs } from "@protontech/autofill/features/feature";
+import * as abstractField from "@protontech/autofill/features/v1/abstract.field";
+import * as abstractForm from "@protontech/autofill/features/v1/abstract.form";
+import * as fieldEmail from "@protontech/autofill/features/v1/field.email";
+import * as fieldOtp from "@protontech/autofill/features/v1/field.otp";
+import * as fieldPassword from "@protontech/autofill/features/v1/field.password";
+import * as fieldUsername from "@protontech/autofill/features/v1/field.username";
+import * as fieldUsernameHidden from "@protontech/autofill/features/v1/field.username-hidden";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+const sources = [
+    ["./abstract.form", abstractForm],
+    ["./abstract.field", abstractField],
+    ["./field.email", fieldEmail],
+    ["./field.otp", fieldOtp],
+    ["./field.password", fieldPassword],
+    ["./field.username", fieldUsername],
+    ["./field.username-hidden", fieldUsernameHidden],
+];
+const isFeature = (v) => typeof v === "object" && v !== null && typeof v.compute === "function";
+const buildFeatureRefs = (sources) => {
+    const refs = new Map();
+    for (const [src, mod] of sources) {
+        for (const [id, val] of Object.entries(mod)) {
+            if (isFeature(val) && !refs.has(val))
+                refs.set(val, { id, src, path: [] });
+        }
+    }
+    for (const [src, mod] of sources) {
+        for (const [id, val] of Object.entries(mod)) {
+            if (!isFeature(val))
+                continue;
+            const walk = (node, path) => {
+                for (const [key, parent] of Object.entries(node.parents)) {
+                    if (refs.has(parent))
+                        continue;
+                    const next = [...path, key];
+                    refs.set(parent, { id, src, path: next });
+                    walk(parent, next);
+                }
+            };
+            walk(val, []);
+        }
+    }
+    return refs;
+};
+const featureRefs = buildFeatureRefs(sources);
+const refOf = (f) => {
+    const ref = featureRefs.get(f);
+    if (!ref)
+        throw new Error(`feature '${f.name}' has no exported declaration.`);
+    return ref;
+};
+const buildComputer = (name, recordSrc, record) => {
+    const outputs = Object.values(record);
+    const computer = {
+        name,
+        recordSrc,
+        sorted: topologicalSort(record),
+        features: outputs.filter((f) => !f.private).map((f) => f.name),
+        private: outputs.filter((f) => f.private).map((f) => f.name),
+    };
+    validateComputerInputs(computer);
+    return computer;
+};
+const BANNER = `// Generated by \`bazel run //pass_ml/js/autofill:write_sorted_features\`. Do not edit.\n\n`;
+const RUNTIME_IMPORT = `import { getComputerForFeatures } from "@protontech/autofill/features/feature";`;
+const fmtImportSpec = (id, alias) => (alias === id ? id : `${id} as ${alias}`);
+const fmtImportLine = (prefix, src, specs) => `${prefix} { ${specs.join(", ")} } from "${src}";`;
+const fmtNameList = (names) => names.map((n) => `"${n}"`).join(", ");
+const fmtComputerExport = (name, recordType, sortedRefs, features, privateOutputs) => `export const ${name}Computer = getComputerForFeatures<typeof ${recordType}>({
+      sorted: [${sortedRefs.map((r) => `    ${r},`).join("\n")}],
+      features: [${fmtNameList(features)}],
+      private: [${fmtNameList(privateOutputs)}],
+});`;
+const fmtFile = (imports, exports) => `${BANNER}\n${imports}\n\n${exports}\n`;
+const render = (computers) => {
+    const valueImports = {};
+    const typeImports = {};
+    const srcsById = {};
+    const track = (bucket, src, id) => {
+        var _a, _b;
+        ((_a = bucket[src]) !== null && _a !== void 0 ? _a : (bucket[src] = new Set())).add(id);
+        ((_b = srcsById[id]) !== null && _b !== void 0 ? _b : (srcsById[id] = new Set())).add(src);
+    };
+    for (const c of computers) {
+        track(typeImports, c.recordSrc, c.name);
+        for (const f of c.sorted) {
+            const { src, id } = refOf(f);
+            track(valueImports, src, id);
+        }
+    }
+    const importAlias = (src, id) => {
+        var _a;
+        if (srcsById[id].size === 1)
+            return id;
+        return `${id}_${(_a = src.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(/[.-]/g, "_")}`;
+    };
+    const importLinesFor = (bucket, prefix) => Object.entries(bucket).map(([src, ids]) => {
+        const specs = [...ids].map((id) => fmtImportSpec(id, importAlias(src, id)));
+        return fmtImportLine(prefix, src, specs);
+    });
+    const imports = [RUNTIME_IMPORT, ...importLinesFor(valueImports, "import"), ...importLinesFor(typeImports, "import type")].join("\n");
+    const refExpr = (f) => {
+        const { src, id, path } = refOf(f);
+        return path.reduce((acc, key) => `${acc}.parents.${key}`, importAlias(src, id));
+    };
+    const exports = computers.map((c) => fmtComputerExport(c.name, importAlias(c.recordSrc, c.name), c.sorted.map(refExpr), c.features, c.private)).join("\n\n");
+    return fmtFile(imports, exports);
+};
+const writeOut = (path, content) => {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+};
+const [, , formsOut, fieldsOut] = process.argv;
+if (!formsOut || !fieldsOut)
+    throw new Error("usage: gen-sorted-features <forms-out.ts> <fields-out.ts>");
+const formComputers = [buildComputer("formFeatures", "./abstract.form", abstractForm.formFeatures)];
+const fieldComputers = [
+    buildComputer("fieldFeatures", "./abstract.field", abstractField.fieldFeatures),
+    buildComputer("emailFeatures", "./field.email", fieldEmail.emailFeatures),
+    buildComputer("otpFeatures", "./field.otp", fieldOtp.otpFeatures),
+    buildComputer("passwordFeatures", "./field.password", fieldPassword.passwordFeatures),
+    buildComputer("usernameFeatures", "./field.username", fieldUsername.usernameFeatures),
+    buildComputer("usernameHiddenFeatures", "./field.username-hidden", fieldUsernameHidden.usernameHiddenFeatures),
+];
+writeOut(formsOut, render(formComputers));
+writeOut(fieldsOut, render(fieldComputers));

package/types/index.d.ts

@@ -71,13 +71,14 @@ export type Feature<N extends string, R, P extends AbstractFeatures> = {
     name: N;
     parents: P;
     compute(parents: InferParentComputeType<P>, fnode: Fnode): R;
+    private?: true;
 };
 export type ComputedFeatures<F extends AbstractFeatures> = {
     [K in keyof F as F[K]["name"]]: ReturnType<F[K]["compute"]>;
 };
 export interface FeatureComputer<F extends AbstractFeatures = AbstractFeatures> {
     compute(fnode: Fnode): ComputedFeatures<F>;
-    features: AbstractFeature[];
+    features: string[];
 }
 export type ModelProviderRegistry = Record<ModelName, ModelProvider>;
 export type ModelName = string;

package/utils/fathom.d.ts

@@ -1,5 +1,4 @@
 import type { Fnode } from "@protontech/fathom";
-import type { AbstractFeature } from "@protontech/autofill/types";
 export declare const TOLERANCE_LEVEL = 0.5;
 export declare const boolInt: (val: boolean) => number;
 export declare const safeInt: (val: number, fallback?: number) => number;
@@ -7,7 +6,7 @@ export declare const typeEffect: (type: string) => (fnode: Fnode) => Fnode;
 export declare const processFormEffect: (fnode: Fnode) => Fnode;
 export declare const processFieldEffect: (fnode: Fnode) => Fnode;
 type ClassNote = "form" | "new-password-field" | "password-field" | "username-field" | "username-hidden-field" | "email-field" | "otp-field";
-export declare const featureScore: <F extends AbstractFeature>(noteFor: ClassNote, feat: F) => import("@protontech/fathom").Side;
+export declare const featureScore: (noteFor: ClassNote, featName: string) => import("@protontech/fathom").Side;
 export declare const getParentFormFnode: (fieldFnode: Fnode) => Fnode | null;
 export declare const typeScoreToleranceTest: (type: string) => (fnode: Fnode) => boolean;
 export declare const getTypeScore: (node: Fnode | null, type: string) => number;

package/utils/fathom.js

@@ -20,9 +20,9 @@ export const processFieldEffect = throughEffect((fnode) => {
     if (visible || type === "hidden")
         flagAsProcessed(fnode.element);
 });
-export const featureScore = (noteFor, feat) => score((fnode) => {
+export const featureScore = (noteFor, featName) => score((fnode) => {
     const note = fnode.noteFor(noteFor);
-    return Number(note[feat.name]);
+    return Number(note[featName]);
 });
 export const getParentFormFnode = (fieldFnode) => {
     const field = fieldFnode.element;