@protontech/autofill 0.0.35059265 → 0.0.36026908

package/package.json

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

package/rules/v1/index.js

@@ -2,22 +2,22 @@ import { FEATURE_SEPARATOR } from "@protontech/autofill/constants/features";
 import { formCandidateSelector } from "@protontech/autofill/constants/selectors";
 import { computeFeatures } from "@protontech/autofill/features/feature";
 import { FieldType, FormType } from "@protontech/autofill/types";
-import { isCCInputField, isCCSelectField } from "@protontech/autofill/utils/credit-card";
+import { isCCInputField, isIdentity, maybeEmail, maybeHiddenUsername, maybeOTP, maybePassword, maybeUsername } from "@protontech/autofill/features/v1/field-predicates";
+import { isCCSelectField } from "@protontech/autofill/utils/credit-card";
 import { featureScore, isNoopForm, outRuleWithCache, processFieldEffect, processFormEffect, withFnodeEl } from "@protontech/autofill/utils/fathom";
-import { isClassifiableField, maybeEmail, maybeHiddenUsername, maybeOTP, maybePassword, maybeUsername } from "@protontech/autofill/utils/field";
+import { isClassifiableField } from "@protontech/autofill/utils/field";
 import { isClassifiable } from "@protontech/autofill/utils/flags";
-import { isIdentity } from "@protontech/autofill/utils/identity";
 import { overrides } from "@protontech/autofill/utils/overrides";
 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/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/credit-card.d.ts

@@ -27,6 +27,5 @@ export declare const getCCHaystack: (field: HTMLElement) => string;
 export declare const getCachedCCSubtype: (el: HTMLElement) => CCFieldType | undefined;
 export declare const getCCFieldType: (field: CCFieldElement) => CCFieldType | undefined;
 export declare const matchCCFieldCandidate: (input: HTMLInputElement, { visible }: CCFieldMatchParams) => boolean;
-export declare const isCCInputField: (fnode: Fnode) => boolean;
 export declare const isCCSelectField: (fnode: Fnode) => boolean;
 export {};

package/utils/credit-card.js

@@ -7,7 +7,7 @@ import { matchCCExp, matchCCExpMonth, matchCCExpYear, matchCCFirstName, matchCCL
 import { sanitizeString, sanitizeStringWithSpaces } from "./text";
 import { isVisible } from "./visible";
 export const CC_ATTRIBUTES = ["autocomplete", "name", "id", "class", "form", "aria-label", "aria-labelledby", "placeholder", "data-testid", "data-stripe", "data-recurly", "data-encrypted-name"];
-export const CC_INPUT_TYPES = ["tel", "phone", "text", "number", "password"];
+export const CC_INPUT_TYPES = ["tel", "text", "number", "password"];
 const CC_EXP_YEAR_FORMAT = ["YYYY", "AAAA", "YY", "AA"];
 const CC_EXP_MONTH_FORMAT = ["MM", "LL"];
 const CC_EXP_FULL_RE = /(mmyy|mmaa|yymm|aamm)/;
@@ -212,8 +212,7 @@ export const getCCFieldType = (field) => {
     const cachedSubType = getCachedCCSubtype(field);
     if (cachedSubType)
         return cachedSubType;
-    const type = field.getAttribute("type");
-    if (field.tagName === "INPUT" && type && !CC_INPUT_TYPES.includes(type))
+    if (field.tagName === "INPUT" && !CC_INPUT_TYPES.includes(field.type))
         return;
     const haystack = getCCHaystack(field);
     const autocompletes = getAutocompletes(field);
@@ -234,12 +233,6 @@ export const matchCCFieldCandidate = (input, { visible }) => {
         setCachedSubType(input, ccType);
     return ccType !== undefined;
 };
-export const isCCInputField = (fnode) => {
-    const { isCC, visible } = fnode.noteFor("field");
-    if (!visible)
-        return false;
-    return isCC;
-};
 export const isCCSelectField = (fnode) => {
     const select = fnode.element;
     if (!(select instanceof HTMLSelectElement))

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;

package/utils/field.d.ts

@@ -7,11 +7,10 @@ export declare const isSelect: (el: HTMLElement) => el is HTMLSelectElement;
 export declare const isTextarea: (el: HTMLElement) => el is HTMLTextAreaElement;
 export declare const splitFieldsByVisibility: (els: HTMLElement[]) => [HTMLElement[], HTMLElement[]];
 export declare const fType: (type: FieldType) => (fnode: Fnode) => boolean;
-export declare const maybeEmail: (value: Fnode) => boolean;
-export declare const maybePassword: (value: Fnode) => boolean;
-export declare const maybeOTP: (value: Fnode) => boolean;
-export declare const maybeUsername: (value: Fnode) => boolean;
-export declare const maybeHiddenUsername: (value: Fnode) => boolean;
+export declare const fInput: (types: string[]) => (fnode: Fnode) => boolean;
+export declare const fMatch: (selector: string) => (fnode: Fnode) => boolean;
+export declare const fMode: (mode: string) => (fnode: Fnode) => boolean;
+export declare const fList: (fnode: Fnode) => boolean;
 export declare const isUsernameCandidate: (el: HTMLInputElement) => boolean;
 export declare const isEmailCandidate: (el: HTMLInputElement) => boolean;
 export declare const isOAuthCandidate: (el: HTMLElement) => boolean;

package/utils/field.js

@@ -1,6 +1,6 @@
 import { MIN_AREA_SUBMIT_BTN } from "@protontech/autofill/constants/heuristics";
-import { inputCandidateSelector, kPasswordSelector, kUsernameSelector } from "@protontech/autofill/constants/selectors";
-import { and, any, not, or } from "./combinators";
+import { inputCandidateSelector } from "@protontech/autofill/constants/selectors";
+import { any } from "./combinators";
 import { getAllFieldHaystacks } from "./extract";
 import { getParentFormFnode } from "./fathom";
 import { isClassifiable, isHidden, isProcessed } from "./flags";
@@ -14,11 +14,6 @@ export const isInputField = (el) => {
 };
 export const isSelect = (el) => el.tagName === "SELECT";
 export const isTextarea = (el) => el.tagName === "TEXTAREA";
-const isActiveFieldFNode = (fnode) => {
-    const el = fnode.element;
-    const { visible } = fnode.noteFor("field");
-    return visible && !el.readOnly && !el.disabled;
-};
 export const splitFieldsByVisibility = (els) => {
     return els.reduce((acc, el) => {
         if (isVisibleField(el))
@@ -29,16 +24,10 @@ export const splitFieldsByVisibility = (els) => {
     }, [[], []]);
 };
 export const fType = (type) => (fnode) => fnode.hasType(type);
-const fInput = (types) => (fnode) => types.includes(fnode.element.type);
-const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
-const fMode = (mode) => (fnode) => fnode.element.inputMode === mode;
-const fActive = (fnode) => isActiveFieldFNode(fnode);
-const fList = (fnode) => fnode.element.getAttribute("aria-autocomplete") === "list" || fnode.element.role === "combobox";
-export const maybeEmail = and(not(fList), or(fInput(["email", "text"]), fMode("email")), fActive);
-export const maybePassword = and(not(fList), fMatch(kPasswordSelector), fActive);
-export const maybeOTP = and(fInput(["text", "number", "tel"]), fActive, not(fList));
-export const maybeUsername = and(not(fList), or(and(not(fMode("email")), fInput(["text", "tel"])), fMatch(kUsernameSelector)), fActive);
-export const maybeHiddenUsername = and(not(fList), fInput(["email", "text", "hidden"]), not(fActive));
+export const fInput = (types) => (fnode) => types.includes(fnode.element.type);
+export const fMatch = (selector) => (fnode) => fnode.element.matches(selector);
+export const fMode = (mode) => (fnode) => fnode.element.inputMode === mode;
+export const fList = (fnode) => fnode.element.getAttribute("aria-autocomplete") === "list" || fnode.element.role === "combobox";
 export const isUsernameCandidate = (el) => el.type === "text" || (el.type === "tel" && any(matchUsername)(getAllFieldHaystacks(el)));
 export const isEmailCandidate = (el) => el.type === "email" || (el.type === "text" && any(matchEmail)(getAllFieldHaystacks(el)));
 export const isOAuthCandidate = (el) => any(matchOAuth)(getAllFieldHaystacks(el));

package/utils/identity.d.ts

@@ -1,4 +1,3 @@
-import type { Fnode } from "@protontech/fathom";
 import { IdentityFieldType } from "@protontech/autofill/types";
 import type { FormClassification } from "./fathom";
 type IdentityFieldMatchParams = {
@@ -11,5 +10,4 @@ export declare const getCachedIdentitySubType: (el: HTMLElement) => IdentityFiel
 export declare const getIdentityHaystack: (input: HTMLInputElement) => string;
 export declare const getIdentityFieldType: (input: HTMLInputElement) => IdentityFieldType | undefined;
 export declare const matchIdentityField: (input: HTMLInputElement, { visible }: IdentityFieldMatchParams) => boolean;
-export declare const isIdentity: (fnode: Fnode) => boolean;
 export {};

package/utils/identity.js

@@ -24,7 +24,7 @@ const IDENTITY_MATCHERS = [
     [IdentityFieldType.ADDRESS, guard({ autocompletes: ["street-address", "address-line1"] }, matchAddress)],
 ];
 const IDENTITY_ATTRIBUTES = ["autocomplete", "name", "id", "data-bhw"];
-const IDENTITY_INPUT_TYPES = ["tel", "phone", "text", "number"];
+const IDENTITY_INPUT_TYPES = ["tel", "text", "number"];
 export const getCachedIdentitySubType = (el) => {
     const subType = getCachedSubType(el);
     if (subType && identityFields.has(subType))
@@ -41,8 +41,7 @@ export const getIdentityFieldType = (input) => {
         return cachedSubType;
     if (getCachedSubType(input) !== undefined)
         return;
-    const type = input.getAttribute("type");
-    if (type && !IDENTITY_INPUT_TYPES.includes(type))
+    if (!IDENTITY_INPUT_TYPES.includes(input.type))
         return;
     if ((_a = input.getAttribute("autocomplete")) === null || _a === void 0 ? void 0 : _a.includes("email"))
         return;
@@ -55,7 +54,6 @@ export const getIdentityFieldType = (input) => {
         return identityType;
     }
 };
-const isAutocompleteListInput = (el) => el.getAttribute("aria-autocomplete") === "list" || el.role === "combobox";
 export const matchIdentityField = (input, { visible }) => {
     if (!visible)
         return false;
@@ -67,22 +65,3 @@ export const matchIdentityField = (input, { visible }) => {
     setCachedSubType(input, identityType);
     return true;
 };
-export const isIdentity = (fnode) => {
-    const input = fnode.element;
-    const { isIdentity, isCC, searchField, isFormLogin, isFormRecovery, visible } = fnode.noteFor("field");
-    if (!visible)
-        return false;
-    if (isCC || !isIdentity)
-        return false;
-    const identityType = getIdentityFieldType(input);
-    if (!identityType)
-        return false;
-    const outlierForm = isFormLogin || isFormRecovery;
-    if (outlierForm)
-        return false;
-    if (isAutocompleteListInput(input))
-        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE].includes(identityType);
-    if (searchField)
-        return [IdentityFieldType.ADDRESS, IdentityFieldType.ZIPCODE, IdentityFieldType.CITY].includes(identityType);
-    return true;
-};

package/dictionary/generate.d.ts

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

package/dictionary/generate.js

@@ -1,51 +0,0 @@
-import { sanitizeString, sanitizeStringWithSpaces } from "@protontech/autofill/utils/text";
-import fs from "node:fs";
-import path from "node:path";
-import regexgen from "regexgen";
-import dictionary from "./source/dictionary";
-const generateRegexes = () => {
-    let output = "";
-    output += "/* Regular expressions auto-generated using `source/dictionary.ts`\n";
-    output += " * Simplified & optimised using `regexgen` for performance. \n";
-    output += " * `TYPE_RE`: i18n regexp for text matches\n";
-    output += " * `TYPE_ATTR_RE`: regexp for node attributes\n";
-    output += " * `TYPE_ATTR_END`: attr ending constraint regexp */\n\n";
-    Object.entries(dictionary).forEach(([name, definition]) => {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const i18n = Object.values((_a = definition.i18n) !== null && _a !== void 0 ? _a : {})
-            .flat()
-            .map(sanitizeString);
-        const attrs = ((_c = (_b = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : []).map(sanitizeString);
-        const prefixes = ((_e = (_d = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _d === void 0 ? void 0 : _d.prefixes) !== null && _e !== void 0 ? _e : []).map(sanitizeString);
-        const attrsExact = ((_g = (_f = definition === null || definition === void 0 ? void 0 : definition.attr) === null || _f === void 0 ? void 0 : _f.exact) !== null && _g !== void 0 ? _g : []).map(sanitizeStringWithSpaces);
-        if (i18n.length > 0) {
-            output += `export const ${name}_RE = ${regexgen(i18n, "")}i;\n`;
-        }
-        if (attrs.length > 0 || attrsExact.length > 0) {
-            const regAttrs = attrs.length > 0 ? regexgen(attrs, "").source : null;
-            const regExact = attrsExact.length > 0 ? `\\b(${regexgen(attrsExact, "").source})\\b` : null;
-            const regPrefixes = prefixes.length > 0 ? regexgen(prefixes, "").source : null;
-            const withPrefixes = (re) => (regPrefixes ? `(?:${regPrefixes})${re}` : re);
-            const re = (() => {
-                if (regAttrs && !regExact)
-                    return withPrefixes(regAttrs);
-                else if (!regAttrs && regExact)
-                    return regExact;
-                else if (regAttrs && regExact)
-                    return `${withPrefixes(regAttrs)}|${regExact}`;
-                return "";
-            })();
-            output += `export const ${name}_ATTR_RE = /${re}/i;\n`;
-        }
-        if (definition === null || definition === void 0 ? void 0 : definition.startsWith) {
-            const startWithRe = regexgen(definition.startsWith.map(sanitizeString), "");
-            output += `export const ${name}_ATTR_START_RE = /\\b(?:${startWithRe.source})\\S+/i;\n`;
-        }
-        if (definition === null || definition === void 0 ? void 0 : definition.endsWith) {
-            const endWordsRe = regexgen(definition.endsWith.map(sanitizeString), "");
-            output += `export const ${name}_ATTR_END_RE= /\\b\\S*(?:${endWordsRe.source})\\b/i;\n`;
-        }
-    });
-    fs.writeFileSync(path.resolve(__dirname, "./generated/dictionary.ts"), output);
-};
-generateRegexes();

package/features/feature.spec.d.ts

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

package/features/feature.spec.js

@@ -1,59 +0,0 @@
-import { feature, featuresProduct, getComputerForFeatures, topologicalSort } from "./feature";
-function doNothing() {
-}
-describe("topological sort", () => {
-    test("it works", () => {
-        const A = feature("A", {}, doNothing);
-        const B = feature("B", { A }, doNothing);
-        const C = feature("C", { A }, doNothing);
-        const D = feature("D", { B, C }, doNothing);
-        const E = feature("E", { B }, doNothing);
-        const F = feature("F", {}, doNothing);
-        const G = feature("G", { E, F }, doNothing);
-        const H = feature("H", {}, doNothing);
-        const features = { D, G, H };
-        const sorted = topologicalSort(features);
-        const nodeNames = sorted.map((feat) => feat.name);
-        expect(nodeNames.slice(0, 3).sort()).toEqual(["A", "F", "H"]);
-        expect(nodeNames.slice(3, 5).sort()).toEqual(["B", "C"]);
-        expect(nodeNames[5]).toEqual("E");
-        expect(nodeNames.slice(6, 8).sort()).toEqual(["D", "G"]);
-    });
-    test("it fails if there is a loop", () => {
-        const A = feature("A", {}, doNothing);
-        const B = feature("B", { A }, doNothing);
-        const C = feature("C", { A }, doNothing);
-        const D = feature("D", { B, C }, doNothing);
-        const E = feature("E", { B }, doNothing);
-        const F = feature("F", {}, doNothing);
-        const G = feature("G", { E, F }, doNothing);
-        const H = feature("H", {}, doNothing);
-        A.parents = { D };
-        const features = { A, B, C, D, E, F, G, H };
-        expect(() => topologicalSort(features)).toThrow(`loop detected with elements:
-  A -> {D}
-  B -> {A}
-  C -> {A}
-  D -> {B, C}
-  E -> {B}
-  G -> {E}`);
-    });
-});
-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 });
-    });
-    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 });
-    });
-});

package/features/registry.d.ts

@@ -1,3 +0,0 @@
-import type { FeatureComputer } from "@protontech/autofill/types";
-export declare const setFormFeaturesComputer: (c: FeatureComputer) => void;
-export declare const getFormFeaturesComputer: () => FeatureComputer;

package/features/registry.js

@@ -1,9 +0,0 @@
-let formFeaturesComputer;
-export const setFormFeaturesComputer = (c) => {
-    formFeaturesComputer = c;
-};
-export const getFormFeaturesComputer = () => {
-    if (!formFeaturesComputer)
-        throw new Error("formFeaturesComputer accessed before registration; features/v1 must be initialised first");
-    return formFeaturesComputer;
-};

package/features/sorted.gen.d.ts

@@ -1,14 +0,0 @@
-export declare const sortedFieldFeatures: import("..").AbstractFeature<unknown>[];
-export declare const fieldFeatureNames: ("text" | "label" | "autocomplete" | "visible" | "attrs" | "isCC" | "isFormLogin" | "parentFormFnode" | "isFormNoop" | "isFormPasswordChange" | "isFormRecovery" | "isFormRegister" | "isIdentity" | "searchField" | "nextField" | "parentFormFeatures" | "prevField" | "prevInput")[];
-export declare const sortedFormFeatures: import("..").AbstractFeature<unknown>[];
-export declare const formFeatureNames: ("__formInputMFACandidates" | "__formMFA" | "formTextMFA" | "formAttrsMFA" | "__formOTPOutlier" | "__formTextAuthenticator" | "inputsMFA" | "__headingsOTPOutlier" | "__inputIterator" | "__linkOTPOutlier" | "visibleFieldsCountScaled" | "visibleInputsCountScaled" | "fieldsetsCountScaled" | "textsCountScaled" | "textareasCountScaled" | "selectsCountScaled" | "disabledCountScaled" | "radiosCountScaled" | "readOnlyCountScaled" | "formComplexityScaled" | "visibleIdentifiersCountScaled" | "hiddenIdentifiersCountScaled" | "usernamesCountScaled" | "emailsCountScaled" | "hiddenCountScaled" | "hiddenPasswordsCountScaled" | "submitsCountScaled" | "identitiesCountScaled" | "ccsCountScaled" | "hasTels" | "hasOAuth" | "hasCaptchas" | "hasFiles" | "hasDate" | "hasNumber" | "oneVisibleField" | "twoVisibleFields" | "threeOrMoreVisibleFields" | "noPasswords" | "onePassword" | "twoPasswords" | "threeOrMorePasswords" | "noIdentifiers" | "oneIdentifier" | "twoIdentifiers" | "threeOrMoreIdentifiers" | "autofocusedIsIdentifier" | "autofocusedIsPassword" | "visibleRatio" | "inputRatio" | "hiddenRatio" | "identifierRatio" | "emailRatio" | "usernameRatio" | "passwordRatio" | "disabledRatio" | "requiredRatio" | "checkboxRatio" | "hiddenIdentifierRatio" | "hiddenPasswordRatio" | "pageLogin" | "formTextLogin" | "formAttrsLogin" | "headingsLogin" | "layoutLogin" | "rememberMeCheckbox" | "troubleLink" | "submitLogin" | "pageRegister" | "formTextRegister" | "formAttrsRegister" | "headingsRegister" | "layoutRegister" | "pwNewRegister" | "pwConfirmRegister" | "submitRegister" | "TOSRef" | "pagePwReset" | "formTextPwReset" | "formAttrsPwReset" | "headingsPwReset" | "layoutPwReset" | "pageRecovery" | "formTextRecovery" | "formAttrsRecovery" | "headingsRecovery" | "layoutRecovery" | "identifierRecovery" | "submitRecovery" | "newsletterForm" | "searchForm" | "multistepForm" | "multiAuthForm" | "multistepForm,multiAuthForm" | "visibleRatio,visibleFieldsCountScaled" | "visibleRatio,visibleIdentifiersCountScaled" | "visibleRatio,visiblePasswordsCountScaled" | "visibleRatio,hiddenIdentifiersCountScaled" | "visibleRatio,hiddenPasswordsCountScaled" | "visibleRatio,multiAuthForm" | "visibleRatio,multistepForm" | "identifierRatio,visibleFieldsCountScaled" | "identifierRatio,visibleIdentifiersCountScaled" | "identifierRatio,visiblePasswordsCountScaled" | "identifierRatio,hiddenIdentifiersCountScaled" | "identifierRatio,hiddenPasswordsCountScaled" | "identifierRatio,multiAuthForm" | "identifierRatio,multistepForm" | "passwordRatio,visibleFieldsCountScaled" | "passwordRatio,visibleIdentifiersCountScaled" | "passwordRatio,visiblePasswordsCountScaled" | "passwordRatio,hiddenIdentifiersCountScaled" | "passwordRatio,hiddenPasswordsCountScaled" | "passwordRatio,multiAuthForm" | "passwordRatio,multistepForm" | "requiredRatio,visibleFieldsCountScaled" | "requiredRatio,visibleIdentifiersCountScaled" | "requiredRatio,visiblePasswordsCountScaled" | "requiredRatio,hiddenIdentifiersCountScaled" | "requiredRatio,hiddenPasswordsCountScaled" | "requiredRatio,multiAuthForm" | "requiredRatio,multistepForm")[];
-export declare const sortedEmailFeatures: import("..").AbstractFeature<unknown>[];
-export declare const emailFeatureNames: ("fieldCC" | "fieldIdentity" | "isSearchField" | "attrEmail" | "autocompleteEmail" | "autocompleteOff" | "typeEmail" | "exactAttrEmail" | "textEmail" | "labelEmail" | "placeholderEmail" | "mfaOutlier")[];
-export declare const sortedOtpFeatures: import("..").AbstractFeature<unknown>[];
-export declare const otpFeatureNames: ("formComplexity" | "fieldCC" | "fieldIdentity" | "formMFA" | "formAuthenticator" | "outlierForm" | "outlierLink" | "outlierHeadings" | "numericMode" | "patternOTP" | "nameMatch" | "idMatch" | "autocompleteOTC" | "singleInput" | "siblingOfInterest" | "attrOTP" | "attrMFA" | "textMFA" | "textAuthenticator" | "labelOTP" | "labelMFA" | "labelAuthenticator" | "outlierMaxLength" | "outlierInputCount" | "outlierEmailMatchScaled" | "outlierField" | "outlierSearch" | "outlierAutocomplete")[];
-export declare const sortedPasswordFeatures: import("..").AbstractFeature<unknown>[];
-export declare const passwordFeatureNames: ("fieldCC" | "fieldIdentity" | "autocompleteOff" | "fieldLogin" | "fieldRegister" | "fieldExotic" | "passwordOutlier" | "autocompleteNew" | "autocompleteCurrent" | "autocompleteOTP" | "attrCurrent" | "textCurrent" | "labelCurrent" | "attrCreate" | "textCreate" | "labelCreate" | "attrConfirm" | "textConfirm" | "labelConfirm" | "attrReset" | "prevPwField" | "prevPwNew" | "prevPwCurrent" | "nextPwField" | "nextPwNew" | "nextPwConfirm" | "nextPwCurrent" | "fieldLogin,autocompleteNew" | "fieldLogin,maybeNew" | "fieldRegister,autocompleteCurrent" | "fieldRegister,maybeCurrent" | "prevPwCurrent,nextPwNew")[];
-export declare const sortedUsernameFeatures: import("..").AbstractFeature<unknown>[];
-export declare const usernameFeatureNames: ("fieldCC" | "fieldIdentity" | "isSearchField" | "autocompleteUsername" | "attrUsername" | "autocompleteEmail" | "autocompleteOff" | "textUsername" | "labelUsername" | "outlierAttrs" | "outlierText" | "outlierLabel" | "outlierEmail" | "firstLoginFormField")[];
-export declare const sortedUsernameHiddenFeatures: import("..").AbstractFeature<unknown>[];
-export declare const usernameHiddenFeatureNames: ("fieldCC" | "fieldIdentity" | "autocompleteUsername" | "attrEmail" | "attrUsername" | "autocompleteEmail" | "fieldExotic" | "visibleReadonly" | "attrMatch" | "valueEmail" | "valueTel" | "valueUsername")[];

package/features/sorted.gen.js

@@ -1,22 +0,0 @@
-import { topologicalSort } from "@protontech/autofill/features/feature";
-import { fieldFeatures } from "./v1/abstract.field";
-import { formFeatures } from "./v1/abstract.form";
-import { emailFeatures } from "./v1/field.email";
-import { otpFeatures } from "./v1/field.otp";
-import { passwordFeatures } from "./v1/field.password";
-import { usernameFeatures } from "./v1/field.username";
-import { usernameHiddenFeatures } from "./v1/field.username-hidden";
-export const sortedFieldFeatures = topologicalSort(fieldFeatures);
-export const fieldFeatureNames = Object.values(fieldFeatures).map((f) => f.name);
-export const sortedFormFeatures = topologicalSort(formFeatures);
-export const formFeatureNames = Object.values(formFeatures).map((f) => f.name);
-export const sortedEmailFeatures = topologicalSort(emailFeatures);
-export const emailFeatureNames = Object.values(emailFeatures).map((f) => f.name);
-export const sortedOtpFeatures = topologicalSort(otpFeatures);
-export const otpFeatureNames = Object.values(otpFeatures).map((f) => f.name);
-export const sortedPasswordFeatures = topologicalSort(passwordFeatures);
-export const passwordFeatureNames = Object.values(passwordFeatures).map((f) => f.name);
-export const sortedUsernameFeatures = topologicalSort(usernameFeatures);
-export const usernameFeatureNames = Object.values(usernameFeatures).map((f) => f.name);
-export const sortedUsernameHiddenFeatures = topologicalSort(usernameHiddenFeatures);
-export const usernameHiddenFeatureNames = Object.values(usernameHiddenFeatures).map((f) => f.name);

package/features/v1/index.spec.d.ts

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

package/features/v1/index.spec.js

@@ -1,30 +0,0 @@
-import { topologicalSort } from "@protontech/autofill/features/feature";
-import { fieldFeatures } from "./abstract.field";
-import { formFeatures } from "./abstract.form";
-import { emailFeatures } from "./field.email";
-import { otpFeatures } from "./field.otp";
-import { passwordFeatures } from "./field.password";
-import { usernameFeatures } from "./field.username";
-import { usernameHiddenFeatures } from "./field.username-hidden";
-describe("features can be topologically sorted", () => {
-    const featureSets = {
-        fieldFeatures,
-        formFeatures,
-        emailFeatures,
-        otpFeatures,
-        passwordFeatures,
-        usernameHiddenFeatures,
-        usernameFeatures,
-    };
-    Object.entries(featureSets).forEach(([featureSetName, features]) => test(`${featureSetName} can be topologically sorted`, () => {
-        try {
-            topologicalSort(features);
-        }
-        catch (error) {
-            console.log(Object.values(features)
-                .map((feature) => `${feature.name} -> {${Object.keys(feature.parents).join(", ")}}`)
-                .join("\n"));
-            throw error;
-        }
-    }));
-});

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

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

package/scripts/gen-sorted-features.js

@@ -1,32 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { topologicalSort } from "../features/feature";
-import { fieldFeatures } from "../features/v1/abstract.field";
-import { formFeatures } from "../features/v1/abstract.form";
-import { emailFeatures } from "../features/v1/field.email";
-import { otpFeatures } from "../features/v1/field.otp";
-import { passwordFeatures } from "../features/v1/field.password";
-import { usernameFeatures } from "../features/v1/field.username";
-import { usernameHiddenFeatures } from "../features/v1/field.username-hidden";
-const sets = [
-    { name: "fieldFeatures", sourceModule: "./v1/abstract.field", features: fieldFeatures },
-    { name: "formFeatures", sourceModule: "./v1/abstract.form", features: formFeatures },
-    { name: "emailFeatures", sourceModule: "./v1/field.email", features: emailFeatures },
-    { name: "otpFeatures", sourceModule: "./v1/field.otp", features: otpFeatures },
-    { name: "passwordFeatures", sourceModule: "./v1/field.password", features: passwordFeatures },
-    { name: "usernameFeatures", sourceModule: "./v1/field.username", features: usernameFeatures },
-    { name: "usernameHiddenFeatures", sourceModule: "./v1/field.username-hidden", features: usernameHiddenFeatures },
-];
-for (const { features } of sets)
-    topologicalSort(features);
-const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-const namesExport = (setName) => setName.replace(/Features$/, "FeatureNames");
-const sortedExport = (setName) => `sorted${capitalize(setName)}`;
-const banner = "// Generated by `bazel run //pass_ml/js/autofill:write_sorted_features` — do not edit.\n";
-const imports = [`import { topologicalSort } from "@protontech/autofill/features/feature";`, ...sets.map(({ name, sourceModule }) => `import { ${name} } from "${sourceModule}";`)].join("\n");
-const exports = sets.flatMap(({ name }) => [`export const ${sortedExport(name)} = topologicalSort(${name});`, `export const ${namesExport(name)} = Object.values(${name}).map((f) => f.name);`]).join("\n");
-const outPath = process.argv[2];
-if (!outPath)
-    throw new Error("usage: gen-sorted-features <out.ts>");
-mkdirSync(dirname(outPath), { recursive: true });
-writeFileSync(outPath, `${banner}\n${imports}\n\n${exports}\n`);

package/utils/credit-card.samples.spec.d.ts

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