@ofidj/entry 3.10.0 → 3.11.0

package/README.md

@@ -26,10 +26,86 @@ renders, so there is one implementation and no hand-porting.
 npm install @ofidj/entry
 ```
 
-```ts
-import { providerEntry, bindAgreement, acceptedAgreement } from "@ofidj/entry";
+Three entry points, split by what they need to run:
+
+| Import                | Needs            | What it holds                                                                  |
+| --------------------- | ---------------- | ------------------------------------------------------------------------------ |
+| `@ofidj/entry`        | nothing          | **the model**: every rule, and every sentence a person is shown, as plain data |
+| `@ofidj/entry/dom`    | a document       | one renderer of that model as HTML strings, and the helpers that drive it      |
+| `@ofidj/entry/window` | a browser window | the Fidj window and the answer it relays back                                  |
+
+The root is pure — no DOM, no markup, no view layer. That is deliberate: a
+screen is a **value**, so the same entry can be drawn as HTML strings, as React
+components or as Vue single-file components, and none of them re-derives a rule
+or re-types a sentence.
+
+### On React, Vue, Svelte, or a server
+
+Take the model and render it yourself. Nothing here assumes a browser, so it
+works under SSR, in a test, or in a plain Node script.
+
+```tsx
+import {
+  agreementModel,
+  acceptance,
+  agreementRequired,
+  agreementFromRefusal,
+  verificationPending,
+  pollVerification,
+  signInErrorMessage,
+} from "@ofidj/entry";
+import { openProviderWindow } from "@ofidj/entry/window";
 import "@ofidj/entry/tokens.css";
 import "@ofidj/entry/style.css";
+
+function Agreement({ title, agreement, onAccepted }) {
+  const [checked, setChecked] = useState(false);
+  const screen = agreementModel(title, agreement, { checked });
+  return (
+    <form
+      onSubmit={() =>
+        onAccepted(acceptance({ checked, version: screen.version }))
+      }
+    >
+      <h2>{screen.heading}</h2>
+      <p className="signin-lead">{screen.lead}</p>
+      <p className="fineprint">{screen.versionLabel}</p>
+      <div className="agreement-text" tabIndex={0}>
+        {screen.text}
+      </div>
+      <label className="agreement-choice">
+        <input
+          type="checkbox"
+          checked={checked}
+          onChange={(e) => setChecked(e.target.checked)}
+        />
+        <span>{screen.checkboxLabel}</span>
+      </label>
+      <button className="primary" disabled={screen.submitDisabled}>
+        {screen.submitLabel}
+      </button>
+    </form>
+  );
+}
+```
+
+`acceptance()` is the rule `@ofidj/entry/dom` applies to a checkbox, asked of
+your own state instead: a tick is evidence only if it was live and only if it
+names the version that was displayed. Both callers have to get the same answer,
+or the evidence means different things depending on who collected it.
+
+Authentication itself is not here — that is `@ofidj/node`. This package is the
+screens and the flow around them.
+
+### On a shell that builds pages out of strings
+
+```ts
+import { agreementRequired, agreementFromRefusal } from "@ofidj/entry";
+import {
+  agreementScreen,
+  bindAgreementScreen,
+  acceptedAgreement,
+} from "@ofidj/entry/dom";
 ```
 
 `tokens.css` defines every colour, family and radius the product paints with;
@@ -39,24 +115,81 @@ prefix.
 
 ## What is here, and what is not
 
-Moved, and covered by characterization tests in `test/`:
+| Module                                 | What it holds                                                                                                                           |
+| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `model.ts`                             | the refusals and what they mean, the acceptance rule, and a model per screen: entry, agreement, verification wait, account, credentials |
+| `remembered.ts`                        | the address this browser remembers, and forgetting it                                                                                   |
+| `dom.ts`                               | the HTML renderer, the agreement binding, the folding form, the `fidj@<version>` badge                                                  |
+| `provider-window.ts`                   | the Fidj window and the answer it relays back                                                                                           |
+| `tokens.css`, `fonts.css`, `style.css` | the design system                                                                                                                       |
+
+Two tests hold the split, and they are the reason it stays true. One exercises
+every model function in a file that never loads jsdom and never defines `window`
+or `document`. The other asserts the HTML renderer says **what the model says**
+and invents nothing — because a sentence able to drift between the two is a
+React app and a generated app telling the same person different things, which is
+the failure this package exists to end.
+
+Still in `generator-fidj`'s template, and next to move: the Fidj-hosted OIDC
+interaction page. It imports `app.config.json` directly, so it moves behind a
+config argument rather than verbatim.
 
-| Module                                 | What it holds                                                                                                      |
-| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| `service-agreement.ts`                 | the agreement block and its loading, `providerEntry`'s three shapes, the remembered address, sign-in error wording |
-| `provider-window.ts`                   | the Fidj window and the answer it relays back                                                                      |
-| `version.ts`                           | the `fidj@<version>` badge                                                                                         |
-| `tokens.css`, `fonts.css`, `style.css` | the design system                                                                                                  |
+## The entry flow
 
-Still in `generator-fidj`'s template, and next to move: the screens inside
-`content.ts` — the sign-in entry, `#/forgot`, `#/reset`, `#/verify`, `#/account`
-and the Fidj-hosted OIDC interaction page. They import `app.config.json`
-directly, so they move behind a config argument rather than verbatim.
+[The workspace README](../README.md#entry-one-flow-the-same-everywhere) defines
+it; this package implements it, so every surface gets the same one.
+
+```ts
+import {
+  pollVerification, // the wait ends by itself when the link is opened
+  agreementRequired, // was this refusal "you owe this app its agreement"?
+  agreementFromRefusal, // ...and the agreement it refused with
+  verificationPending, // was it "nobody has proved this address yet"?
+  credentialsModel, // email, password, two buttons, nothing gated
+  verificationWaitModel, // the wait a new account owes its address
+  agreementModel, // the second screen, and when its submit is live
+} from "@ofidj/entry";
+import {
+  credentialFields,
+  verificationWait,
+  agreementScreen,
+  bindAgreementScreen,
+} from "@ofidj/entry/dom"; // ...the same screens, as markup
+```
 
-**The generator has not switched over yet.** Its template still carries its own
-copies and builds from them, so a change made here reaches nobody until that
-lands. `test/no-drift-from-the-generator.test.mjs` fails while the two disagree,
-and is deleted in the same change that deletes the generator's copies.
+**The API decides, not the screen.** Call `login`, and when it refuses with
+`409 agreement_required`, show the agreement screen. A screen that decided for
+itself
+would have to know which version the account already accepted, which is the
+API's to know — and an owner publishing a new version is what makes the
+question owed again.
+
+**Read the agreement off the refusal.** `agreementFromRefusal` returns the
+version and text the API compared against, from `FidjError.details`. Fetching it
+again with `GET /apps/:appId` usually gives the same answer and occasionally
+not: an owner who publishes between the refusal and the refetch would have
+somebody accept text the API is about to call stale. It needs `@ofidj/node`
+3.10.2 or later, where `login` stopped rebuilding its error from
+`err.toString()` and losing the body; against an older SDK it returns `null` and
+the caller falls back to fetching.
+
+**The wait is not a screen.** `verificationWait` returns a block to put _under_
+the credential form, which stays where it is. That is what keeps a mistyped
+address correctable: the field is still there, still filled in — correcting it
+and creating the account again is the repair, and it reads as one because
+nothing moved.
+
+**`pollVerification` treats a failed check as no answer.** A browser that lost
+its connection has learned nothing about the address, so the wait continues
+rather than reporting anything.
+
+### What went with the old arrangement
+
+`agreementMarkup` and `bindAgreement` are gone. They put the checkbox beside the
+credentials and gated the submit on whether the agreement had _loaded_, ticked or
+not; the generated shells both render the two screens now, so nothing called
+them. `agreementScreen` and `bindAgreementScreen` replace them, and the tick is
+what opens the door.
 
 ## Release
 

package/dom.d.ts

@@ -0,0 +1,27 @@
+import { type AccountState, type SigninShape, type VerificationState } from "./index.js";
+export declare const escape: (value: unknown) => string;
+export declare function masthead(logo: string, title: string): string;
+export declare function highlightCells(entries?: Array<{
+    heading: string;
+    body: string;
+}>): string;
+export declare function badgeStrip(entries?: string[]): string;
+export declare function credentialFields(state: {
+    email: string;
+    password: string;
+}): string;
+export declare function accountForm(route: string, state: AccountState): string;
+export declare function returnNotice(asking: string): string;
+export declare function providerEntry(title: string, appId: string, credentials: string, isFidjItself?: boolean, shape?: SigninShape): string;
+export declare function agreementScreen(title: string, agreement: {
+    version?: string;
+    text?: string;
+}): string;
+export declare function verificationWait(state: VerificationState): string;
+export declare function acceptedAgreement(form: HTMLFormElement): {
+    termsAccepted: boolean;
+    termsVersion: string;
+} | null;
+export declare function bindAgreementScreen(form: HTMLFormElement | null): void;
+export declare function showEmailEntry(open: boolean, focus?: boolean): void;
+export declare function showVersionBadge(version: string, apiEndpoint?: string): void;

package/dom.js

@@ -0,0 +1,224 @@
+// The entry, as markup and as behaviour.
+//
+// One renderer of the model in `@ofidj/entry`, for the shells that build pages
+// out of strings. Every sentence on these screens comes from the model rather
+// than from here — that is the property worth keeping, because it is what makes
+// a React or Vue app render the *same* entry instead of a similar one.
+//
+// What stayed out of the model is the shell that holds the screens: the sign-in
+// screen nests signin-trust inside its inner div and the interaction screen
+// makes it a sibling, so a single shell builder would have had to change one of
+// them. That is a decision, not a move.
+import { accountModel, agreementModel, credentialsModel, providerEntryModel, returnNoticeModel, signInHint, verificationWaitModel, } from "./index.js";
+export const escape = (value) => String(value ?? "").replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+const attribute = (name, value) => value === undefined || value === false || value === ""
+    ? ""
+    : ` ${name}="${escape(value)}"`;
+const button = (control, extraClass = "") => {
+    const classes = [
+        control.kind === "primary"
+            ? "primary"
+            : control.kind === "secondary"
+                ? "secondary"
+                : "quiet",
+        extraClass,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    // A control the entry's own form posts is a submit; one that only changes
+    // what is on screen is not, and saying so is what keeps a disclosure from
+    // opening a second window.
+    const type = control.name ? "submit" : "button";
+    return `<button class="${classes}" type="${type}"${attribute("id", control.name ? "" : control.id)}${attribute("name", control.name)}${attribute("value", control.value)}>${escape(control.label)}</button>`;
+};
+// The app's own mark beside its own name, decorative because the name is right
+// there: every shell opens with this.
+export function masthead(logo, title) {
+    return `<header class="signin-masthead"><img class="app-mark" src="${escape(logo)}" alt=""><strong>${escape(title)}</strong></header>`;
+}
+export function highlightCells(entries) {
+    if (!entries?.length)
+        return "";
+    return `<div class="signin-highlights">${entries
+        .map((entry, index) => `<article><p class="eyebrow">${String(index + 1).padStart(2, "0")}</p><h2>${escape(entry.heading)}</h2><p>${escape(entry.body)}</p></article>`)
+        .join("")}</div>`;
+}
+export function badgeStrip(entries) {
+    if (!entries?.length)
+        return "";
+    return `<footer class="signin-badges">${entries
+        .map((entry) => `<span>${escape(entry)}</span>`)
+        .join("")}</footer>`;
+}
+export function credentialFields(state) {
+    const model = credentialsModel(state);
+    return (`<label for="email">${escape(model.email.label)}</label><input id="email" type="email" value="${escape(model.email.value)}" placeholder="${escape(model.email.placeholder)}" autocomplete="username">` +
+        `<div class="field-head"><label for="password">${escape(model.password.label)}</label><a href="${escape(model.forgot.href)}">${escape(model.forgot.label)}</a></div>` +
+        `<div class="password-field"><input id="password" type="password" value="${escape(model.password.value)}" placeholder="${escape(model.password.placeholder)}" autocomplete="current-password"><button type="button" id="reveal" aria-controls="password">${escape(model.reveal.label)}</button></div>` +
+        `<button class="primary" type="submit" name="entry" value="credentials">${escape(model.submit.label)}</button>` +
+        `<button class="secondary" type="submit" name="signup" value="true">${escape(model.signup.label)}</button>`);
+}
+// The four account screens, drawn from the model that decides which of them has
+// a form to show.
+export function accountForm(route, state) {
+    const model = accountModel(route, state);
+    const fields = model.fields
+        .map((field) => `<label for="${escape(field.id)}">${escape(field.label)}</label><input id="${escape(field.id)}" type="${escape(field.type)}"${attribute("autocomplete", field.autocomplete)}${attribute("minlength", field.minlength)}${field.required ? " required" : ""}>`)
+        .join("");
+    const form = model.submitLabel
+        ? `<form id="recovery">${fields}${model.hint ? `<p>${escape(model.hint)}</p>` : ""}<button class="primary">${escape(model.submitLabel)}</button></form>`
+        : "";
+    const alternative = model.alternative
+        ? `${model.alternative.text ? `<p>${escape(model.alternative.text)}</p>` : ""}${model.alternative.href ? `<a href="${escape(model.alternative.href)}">${escape(model.alternative.label)}</a>` : ""}`
+        : "";
+    if (route === "forgot" || route === "reset" || route === "verify")
+        return `<h2>${escape(model.heading)}</h2><p>${escape(model.intro)}</p>${form}${alternative}`;
+    // My account keeps its own shape: an identity line, a status the page
+    // refreshes in place, and the controls that act on it.
+    return (`<h2>${escape(model.heading)}</h2>` +
+        `<p class="account-identity">Signed in as <strong>${escape(state.accountEmail)}</strong></p>` +
+        `<p>${escape(model.intro)}</p>` +
+        `<p id="verification-status">${escape(model.status)}</p>` +
+        model.extras
+            .map((control) => `<button id="${escape(control.id)}">${escape(control.label)}</button>`)
+            .join("") +
+        `<p><a href="${escape(model.alternative.href)}">${escape(model.alternative.label)}</a></p>`);
+}
+export function returnNotice(asking) {
+    return `<p class="signin-return" role="note">${escape(returnNoticeModel(asking))}</p>`;
+}
+// The entry every app that delegates to the provider renders. The shape logic
+// lives in the model; what is here is the markup and the one browser fact the
+// model refuses to reach for itself — what this browser remembers.
+export function providerEntry(title, appId, credentials, isFidjItself = false, shape = "button") {
+    const model = providerEntryModel({
+        title,
+        hint: signInHint(appId),
+        isFidjItself,
+        shape,
+        hasCredentials: Boolean(credentials),
+    });
+    const lead = `<p class="signin-lead">${escape(model.lead)}</p>`;
+    if (!model.door)
+        return lead + credentials;
+    const door = button(model.door, "fidj-entry");
+    const forget = model.forget
+        ? `<button type="button" id="${escape(model.forget.id)}" class="quiet">${escape(model.forget.label)}</button>`
+        : "";
+    if (!model.disclosure)
+        return lead + door + forget;
+    // Both doors. The app's own one is a second thought for the person who wants
+    // it, which is what a disclosure is for: it costs one click and takes nothing
+    // away, where a second button of equal weight cost everybody a decision.
+    return (lead +
+        door +
+        forget +
+        `<div class="signin-alternate"><button type="button" id="use-email" class="signin-toggle" aria-expanded="${model.disclosure.expanded}" aria-controls="${escape(model.disclosure.controls)}"><span class="signin-toggle-label">${escape(model.disclosure.label)}<span class="caret" aria-hidden="true"></span></span></button>
+  <div id="${escape(model.disclosure.controls)}" hidden>${credentials}</div></div>`);
+}
+// Screen three, drawn. The version travels on the checkbox so that what is
+// recorded is what was displayed.
+export function agreementScreen(title, agreement) {
+    const model = agreementModel(title, agreement);
+    return `<h2>${escape(model.heading)}</h2>
+  <p class="signin-lead">${escape(model.lead)}</p>
+  <p class="fineprint">${escape(model.versionLabel)}</p>
+  <div class="agreement-text" tabindex="0">${escape(model.text)}</div>
+  <label class="agreement-choice"><input id="service-agreement" type="checkbox" required aria-required="true" data-version="${escape(model.version)}"><span>${escape(model.checkboxLabel)}</span></label>
+  <button class="primary" type="submit"${model.submitDisabled ? " disabled" : ""}>${escape(model.submitLabel)}</button>`;
+}
+// Screen two, drawn under the form that started it.
+export function verificationWait(state) {
+    const model = verificationWaitModel(state);
+    const notice = model.notice
+        ? model.notice.kind === "error"
+            ? `<p role="alert" class="error">${escape(model.notice.text)}</p>`
+            : `<p class="fineprint">${escape(model.notice.text)}</p>`
+        : "";
+    return `<div class="verification-wait">
+  <p role="status"><span class="spinner" aria-hidden="true"></span>${escape(model.status)} <strong>${escape(model.email)}</strong>.</p>
+  <p class="fineprint">${escape(model.fineprint)}</p>
+  ${notice}
+  <button type="button" id="resend-verification">${escape(model.resendLabel)}</button>
+  </div>`;
+}
+// ---------------------------------------------------------------------------
+// Reading and driving a real document
+// ---------------------------------------------------------------------------
+// The acceptance, read off the form that collected it. The rule it applies is
+// `acceptance()` in the model; what is here is where the three facts are found.
+export function acceptedAgreement(form) {
+    const checkbox = form.querySelector("#service-agreement");
+    if (!checkbox?.checked || checkbox.disabled || !checkbox.dataset.version)
+        return null;
+    return { termsAccepted: true, termsVersion: checkbox.dataset.version };
+}
+// The tick is what opens the door, and unticking closes it again. This is the
+// rule generator-fidj's README always claimed and its code never had:
+// bindAgreement gated on whether the agreement had *loaded*, which is the right
+// rule for a checkbox standing beside a password and the wrong one for a screen
+// that exists only to collect it.
+export function bindAgreementScreen(form) {
+    if (!form)
+        return;
+    const checkbox = form.querySelector("#service-agreement");
+    if (!checkbox)
+        return;
+    const submits = form.querySelectorAll('button[type="submit"]');
+    const update = () => submits.forEach((element) => {
+        element.disabled = !checkbox.checked;
+    });
+    checkbox.addEventListener("change", update);
+    update();
+}
+// Opening the app's own form takes the space the Fidj door was using.
+//
+// The two are alternatives, not a list, and watching one fold away as the other
+// arrives is what says so — where a form appearing underneath a button that is
+// still there reads as "and also". The toggle stays put through both states, so
+// it ends up labelling whichever one is on screen: a caret pointing down at a
+// form that is not here yet, and up at the one it would put away.
+export function showEmailEntry(open, focus = false) {
+    const fields = document.getElementById("email-entry");
+    const toggle = document.getElementById("use-email");
+    if (!fields || !toggle)
+        return;
+    toggle.setAttribute("aria-expanded", String(open));
+    fields.hidden = !open;
+    const door = document.querySelector(".fidj-entry");
+    if (door) {
+        door.classList.toggle("is-folded", open);
+        // Out of the tab order and out of the accessibility tree the moment it
+        // starts leaving: something mid-fold is not something to press, and an
+        // animation is not what decides that.
+        if (open)
+            door.setAttribute("aria-hidden", "true");
+        else
+            door.removeAttribute("aria-hidden");
+        door.tabIndex = open ? -1 : 0;
+    }
+    if (open && focus)
+        document.getElementById("email")?.focus();
+}
+export function showVersionBadge(version, apiEndpoint) {
+    if (!/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(version || ""))
+        return;
+    const badge = document.createElement("div");
+    badge.className = "fidj-version";
+    badge.setAttribute("aria-label", `Fidj version ${version}`);
+    badge.textContent = `fidj@${version}`;
+    document.body.append(badge);
+    if (apiEndpoint) {
+        void fetch(`${apiEndpoint.replace(/\/$/, "")}/status`)
+            .then((response) => (response.ok ? response.json() : null))
+            .then((status) => {
+            const apiVersion = status?.version || status?.built;
+            if (!apiVersion)
+                return;
+            badge.textContent = `fidj@${version} · API ${apiVersion}`;
+            badge.setAttribute("aria-label", `Fidj version ${version}, API version ${apiVersion}`);
+        })
+            .catch(() => undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom.js","sourceRoot":"","sources":["../src/dom.ts"],"names":[],"mappings":"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"}

package/index.d.ts

@@ -1,3 +1,2 @@
-export { agreementMarkup, acceptedAgreement, signInErrorMessage, bindAgreement, providerEntry, signInHint, rememberSignIn, forgetSignIn, showEmailEntry, type SigninShape, } from "./service-agreement.js";
-export { openProviderWindow, relayProviderAnswer, type ProviderWindow, } from "./provider-window.js";
-export { showVersionBadge } from "./version.js";
+export { agreementRequired, agreementFromRefusal, verificationPending, signInErrorMessage, acceptance, providerEntryModel, agreementModel, verificationWaitModel, accountModel, credentialsModel, returnNoticeModel, pollVerification, type SigninShape, type EntryControl, type ProviderEntryModel, type AgreementModel, type VerificationState, type VerificationWaitModel, type AccountState, type AccountField, type AccountModel, type CredentialsModel, } from "./model.js";
+export { signInHint, rememberSignIn, forgetSignIn } from "./remembered.js";

package/index.js

@@ -1,11 +1,16 @@
-// The Fidj entry, in one place.
+// The Fidj entry: the rules, and every sentence a person is shown.
 //
-// Everything here was lifted verbatim out of generator-fidj's template, where
-// it could only ship by being generated. It is a package now so that the
-// console can import the same screens a generated app renders, instead of the
-// two being kept in step by hand — which is how the service agreement ended up
-// existing in four copies that no test could diff.
-export { agreementMarkup, acceptedAgreement, signInErrorMessage, bindAgreement, providerEntry, signInHint, rememberSignIn, forgetSignIn, showEmailEntry, } from "./service-agreement.js";
-export { openProviderWindow, relayProviderAnswer, } from "./provider-window.js";
-export { showVersionBadge } from "./version.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0NBQWdDO0FBQ2hDLEVBQUU7QUFDRiw4RUFBOEU7QUFDOUUseUVBQXlFO0FBQ3pFLDhFQUE4RTtBQUM5RSwrRUFBK0U7QUFDL0UsbURBQW1EO0FBQ25ELE9BQU8sRUFDTCxlQUFlLEVBQ2YsaUJBQWlCLEVBQ2pCLGtCQUFrQixFQUNsQixhQUFhLEVBQ2IsYUFBYSxFQUNiLFVBQVUsRUFDVixjQUFjLEVBQ2QsWUFBWSxFQUNaLGNBQWMsR0FFZixNQUFNLHdCQUF3QixDQUFDO0FBQ2hDLE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsbUJBQW1CLEdBRXBCLE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDIn0=
+// This root is pure. No DOM, no markup, no view layer — a screen is a value, so
+// the same entry can be drawn as HTML strings, as React components or as Vue
+// single-file components without any of them re-deriving a rule or re-typing a
+// sentence. That is what the package is for: these screens used to live only in
+// generator-fidj's template, where shipping them meant generating an app, and
+// the alternative — keeping a second copy in step by hand — is what produced
+// four versions of the service agreement that no test could diff.
+//
+// Two subpaths carry what cannot be pure:
+//   @ofidj/entry/dom     the HTML renderer and the helpers that drive a document
+//   @ofidj/entry/window  the Fidj window and the answer it relays back
+export { agreementRequired, agreementFromRefusal, verificationPending, signInErrorMessage, acceptance, providerEntryModel, agreementModel, verificationWaitModel, accountModel, credentialsModel, returnNoticeModel, pollVerification, } from "./model.js";
+export { signInHint, rememberSignIn, forgetSignIn } from "./remembered.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUVBQW1FO0FBQ25FLEVBQUU7QUFDRixnRkFBZ0Y7QUFDaEYsNkVBQTZFO0FBQzdFLCtFQUErRTtBQUMvRSxnRkFBZ0Y7QUFDaEYsOEVBQThFO0FBQzlFLDZFQUE2RTtBQUM3RSxrRUFBa0U7QUFDbEUsRUFBRTtBQUNGLDBDQUEwQztBQUMxQyxpRkFBaUY7QUFDakYsdUVBQXVFO0FBQ3ZFLE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsb0JBQW9CLEVBQ3BCLG1CQUFtQixFQUNuQixrQkFBa0IsRUFDbEIsVUFBVSxFQUNWLGtCQUFrQixFQUNsQixjQUFjLEVBQ2QscUJBQXFCLEVBQ3JCLFlBQVksRUFDWixnQkFBZ0IsRUFDaEIsaUJBQWlCLEVBQ2pCLGdCQUFnQixHQVdqQixNQUFNLFlBQVksQ0FBQztBQUNwQixPQUFPLEVBQUUsVUFBVSxFQUFFLGNBQWMsRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/model.d.ts

@@ -0,0 +1,131 @@
+export type SigninShape = "button" | "inline" | "both";
+export declare function agreementRequired(error: unknown): boolean;
+export declare function agreementFromRefusal(error: unknown): {
+    version: string;
+    text: string;
+} | null;
+export declare function verificationPending(error: unknown): {
+    email: string;
+} | null;
+export declare function signInErrorMessage(error: unknown): "Too many attempts. Please wait before trying again." | "We could not sign in to this account. Check the email and password." | "An account already uses this email. Check the password or sign in instead." | "We cannot reach Fidj right now. Please try again." | "We could not sign in to this account. Please try again.";
+export declare function acceptance(state: {
+    checked?: boolean;
+    disabled?: boolean;
+    version?: string;
+}): {
+    termsAccepted: true;
+    termsVersion: string;
+} | null;
+export type EntryControl = {
+    label: string;
+    id: string;
+    name?: string;
+    value?: string;
+    kind: "primary" | "secondary" | "quiet";
+};
+export type ProviderEntryModel = {
+    shape: SigninShape;
+    lead: string;
+    door: EntryControl | null;
+    forget: EntryControl | null;
+    disclosure: {
+        label: string;
+        controls: string;
+        expanded: boolean;
+    } | null;
+};
+export declare function providerEntryModel(options: {
+    title: string;
+    hint?: string;
+    isFidjItself?: boolean;
+    shape?: SigninShape;
+    hasCredentials?: boolean;
+}): ProviderEntryModel;
+export type AgreementModel = {
+    heading: string;
+    lead: string;
+    versionLabel: string;
+    version: string;
+    text: string;
+    checkboxLabel: string;
+    submitLabel: string;
+    submitDisabled: boolean;
+};
+export declare function agreementModel(title: string, agreement: {
+    version?: string;
+    text?: string;
+}, state?: {
+    checked?: boolean;
+}): AgreementModel;
+export type VerificationState = {
+    email: string;
+    resent?: boolean;
+    error?: string;
+};
+export type VerificationWaitModel = {
+    status: string;
+    email: string;
+    fineprint: string;
+    notice: {
+        kind: "error" | "info";
+        text: string;
+    } | null;
+    resendLabel: string;
+};
+export declare function verificationWaitModel(state: VerificationState): VerificationWaitModel;
+export type AccountState = {
+    linkToken?: string;
+    verificationConfirmed?: boolean;
+    emailVerified?: boolean;
+    accountEmail?: string;
+};
+export type AccountField = {
+    id: string;
+    label: string;
+    type: string;
+    autocomplete?: string;
+    minlength?: number;
+    required?: boolean;
+};
+export type AccountModel = {
+    heading: string;
+    intro: string;
+    fields: AccountField[];
+    hint: string;
+    submitLabel: string;
+    alternative: {
+        text: string;
+        href?: string;
+        label?: string;
+    } | null;
+    status: string;
+    extras: EntryControl[];
+};
+export declare function accountModel(route: string, state: AccountState): AccountModel;
+export type CredentialsModel = {
+    email: AccountField & {
+        value: string;
+        placeholder: string;
+    };
+    password: AccountField & {
+        value: string;
+        placeholder: string;
+    };
+    forgot: {
+        href: string;
+        label: string;
+    };
+    reveal: EntryControl;
+    submit: EntryControl;
+    signup: EntryControl;
+};
+export declare function credentialsModel(state: {
+    email: string;
+    password: string;
+}): CredentialsModel;
+export declare function returnNoticeModel(asking: string): string;
+export declare function pollVerification(options: {
+    check: () => Promise<boolean>;
+    onVerified: () => void;
+    intervalMs?: number;
+}): () => void;