@base316/react 0.1.0 → 0.3.0

package/dist/src/AcceptInvitation.d.ts

@@ -0,0 +1,27 @@
+import { type CSSProperties } from "react";
+/**
+ * The other end of an invitation.
+ *
+ * Reads the token from the URL and says what it is for *before* asking anybody
+ * to sign in, because "join Acme as a Member" is a reason to create an account
+ * and "accept invitation" is not. That preview is the one call here that needs
+ * no session — the person holding the link may have no account at all, which is
+ * the entire reason invitations exist.
+ *
+ * The token is not scrubbed from the URL, unlike a password reset. It is
+ * useless to anybody but the address it was sent to, and leaving it in place
+ * means the page survives a sign-in round trip that navigates away and back —
+ * which is the normal path for somebody who has just created an account.
+ */
+export interface AcceptInvitationProps {
+    /** Supply the token directly. Read from `?invitation=` when omitted. */
+    token?: string;
+    onAccepted?: (organizationId: string) => void;
+    /** Where to send somebody who needs an account first. */
+    signUpUrl?: string;
+    signInUrl?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function AcceptInvitation({ token: supplied, onAccepted, signUpUrl, signInUrl, className, style, }: AcceptInvitationProps): import("react").JSX.Element;
+//# sourceMappingURL=AcceptInvitation.d.ts.map

package/dist/src/AcceptInvitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcceptInvitation.d.ts","sourceRoot":"","sources":["../../src/AcceptInvitation.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAKhE;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,qBAAqB;IACrC,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,gBAAgB,CAAC,EAChC,KAAK,EAAE,QAAQ,EACf,UAAU,EACV,SAAS,EACT,SAAS,EACT,SAAS,EACT,KAAK,GACL,EAAE,qBAAqB,+BA0IvB"}

package/dist/src/ActiveSessions.d.ts

@@ -0,0 +1,21 @@
+import { type CSSProperties } from "react";
+/**
+ * Where this account is signed in, and a way to end the rest.
+ *
+ * The panel somebody opens when they think they have been compromised, which
+ * is why the copy is plain and the button does not hedge. It shows where and
+ * when rather than anything identifying the session itself: the token digest is
+ * the value the database authenticates against and never reaches the browser.
+ *
+ * Revoking keeps the caller's own session. Signing somebody out of the device
+ * they are holding, in response to a button about their *other* devices, would
+ * be a surprise at the worst possible moment.
+ */
+export interface ActiveSessionsProps {
+    /** Called after other sessions are ended, with how many went. */
+    onRevoked?: (count: number) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function ActiveSessions({ onRevoked, className, style }: ActiveSessionsProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ActiveSessions.d.ts.map

package/dist/src/ActiveSessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveSessions.d.ts","sourceRoot":"","sources":["../../src/ActiveSessions.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAK7E;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,mBAAmB;IACnC,iEAAiE;IACjE,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AA+CD,wBAAgB,cAAc,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,mBAAmB,sCAkGlF"}

package/dist/src/ApiKeyManager.d.ts

@@ -0,0 +1,22 @@
+import { type CSSProperties } from "react";
+/**
+ * The signed-in user's credentials for this application's API.
+ *
+ * Drop this on an account or developer-settings page and the account manages
+ * its own keys: issue, rotate, revoke. Reads through the session, never a
+ * customer id from props — the account is whoever the session says it is, so
+ * one user cannot be pointed at another's keys by changing a prop.
+ *
+ * What it deliberately does *not* offer is changing the rate limit. A caller
+ * who can raise their own ceiling does not have one. The limit is shown, and so
+ * are the scopes the plan withholds, which is an upgrade prompt arriving at the
+ * moment somebody actually wants the capability.
+ */
+export declare function ApiKeyManager({ className, style, 
+/** Restrict to one API. Omit to show every one the account can reach. */
+audience, }: {
+    className?: string;
+    style?: CSSProperties;
+    audience?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=ApiKeyManager.d.ts.map

package/dist/src/ApiKeyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiKeyManager.d.ts","sourceRoot":"","sources":["../../src/ApiKeyManager.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAmB7E;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC7B,SAAS,EACT,KAAK;AACL,yEAAyE;AACzE,QAAQ,GACR,EAAE;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB,+BAqWA"}

package/dist/src/Chart.d.ts

@@ -0,0 +1,42 @@
+import { type AggregateKind } from "@base316/sdk";
+import { type CSSProperties } from "react";
+import { type UseCollectionOptions } from "./useCollection";
+/**
+ * A chart, over a collection that was never designed to have one.
+ *
+ * The second proof, and it asks the schema different questions from the board:
+ *
+ *     fieldsFor(fields, "timeAxis")            // "what can be an x-axis?"
+ *     fieldsAggregatableBy(fields, "sum")      // "what can be added up?"
+ *
+ * Neither question mentions a field type, and this file names none. That is the
+ * point: the board found a SELECT, this finds a date and a number, and both did
+ * it by describing what they needed rather than by being configured.
+ *
+ * Drawn as SVG rather than with a charting library. Artifacts and customer
+ * pages both restrict which scripts may load, a charting dependency is larger
+ * than everything else in this package put together, and bars with a baseline
+ * are not the hard part of charting.
+ */
+export interface ChartProps extends UseCollectionOptions {
+    collection: string;
+    /** The date field along the bottom. Discovered when omitted. */
+    x?: string;
+    /**
+     * What to measure.
+     *
+     * Omitted means count the records, which is the question that always has an
+     * answer: a collection may have no numeric field, but it always has rows.
+     */
+    y?: string;
+    /** How to combine. Ignored when counting. */
+    aggregate?: Exclude<AggregateKind, "count">;
+    /** How wide a bar is in time. */
+    bucket?: "day" | "week" | "month";
+    title?: string;
+    height?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Chart({ collection, x, y, aggregate, bucket, title, height, className, style, ...options }: ChartProps): import("react").JSX.Element;
+//# sourceMappingURL=Chart.d.ts.map

package/dist/src/Chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chart.d.ts","sourceRoot":"","sources":["../../src/Chart.tsx"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,aAAa,EAKlB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAGpD,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC5C,iCAAiC;IACjC,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAQD,wBAAgB,KAAK,CAAC,EACrB,UAAU,EACV,CAAC,EACD,CAAC,EACD,SAAiB,EACjB,MAAc,EACd,KAAK,EACL,MAAY,EACZ,SAAS,EACT,KAAK,EACL,GAAG,OAAO,EACV,EAAE,UAAU,+BAiIZ"}

package/dist/src/DataTable.d.ts

@@ -0,0 +1,56 @@
+import { type CollectionRecord, type FieldDescriptor } from "@base316/sdk";
+import { type CSSProperties, type ReactNode } from "react";
+import { type UseCollectionOptions } from "./useCollection";
+/**
+ * A table of data nobody wrote a table for.
+ *
+ * Drop it in with a collection key and it works: it reads the schema, derives
+ * its columns from the field types, sorts on the fields that can be sorted,
+ * searches the ones that can be searched, and offers editing only if this
+ * viewer may write.
+ *
+ *     <DataTable collection="jobs" />
+ *
+ * It never names a field type. Every cell goes through the renderer registry,
+ * so a type added later works here without this file being touched — which is
+ * the same reason a board or a calendar can be built against the same schema.
+ *
+ * Wants a different table? Call `useCollection()` and write one. You keep the
+ * schema loading, the paging, the permission handling and the write errors,
+ * and lose only the markup, which is the part worth replacing.
+ */
+export interface DataTableProps extends UseCollectionOptions {
+    /** The collection key, as the schema defines it. */
+    collection: string;
+    /**
+     * Which fields to show, in order.
+     *
+     * Defaults to every field in its declared position. Name them to trim a wide
+     * collection down to what this screen is about.
+     */
+    columns?: string[];
+    /** Replace the cell for one field. Everything else keeps the default. */
+    renderCell?: (record: CollectionRecord, field: FieldDescriptor) => ReactNode | undefined;
+    /** Row click. Without it, rows are not interactive. */
+    onSelect?: (record: CollectionRecord) => void;
+    /**
+     * Called after this table creates, edits or deletes a record.
+     *
+     * The table refreshes itself; this is for anything else on the page bound to
+     * the same collection. Each component holds its own data and they share no
+     * cache, so without this a `<Chart>` beside a table silently lags by every
+     * record added through it — which is exactly what an agent building against
+     * this hit, with no event to hook.
+     */
+    onChanged?: () => void;
+    /** Hide the search box even when the collection has searchable fields. */
+    hideSearch?: boolean;
+    /** Hide New, Edit and Delete even for a viewer who may write. */
+    readOnly?: boolean;
+    /** Shown when there is nothing to list. */
+    emptyState?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function DataTable({ collection, columns, renderCell, onSelect, onChanged, hideSearch, readOnly, emptyState, className, style, ...options }: DataTableProps): import("react").JSX.Element;
+//# sourceMappingURL=DataTable.d.ts.map

package/dist/src/DataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTable.d.ts","sourceRoot":"","sources":["../../src/DataTable.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAW,MAAM,cAAc,CAAC;AACpF,OAAO,EAAY,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAMrE,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,cAAe,SAAQ,oBAAoB;IAC3D,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,eAAe,KAAK,SAAS,GAAG,SAAS,CAAC;IACzF,uDAAuD;IACvD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9C;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,EACzB,UAAU,EACV,OAAO,EACP,UAAU,EACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,SAAS,EACT,KAAK,EACL,GAAG,OAAO,EACV,EAAE,cAAc,+BA+NhB"}

package/dist/src/DeviceApproval.d.ts

@@ -0,0 +1,30 @@
+import { type CSSProperties } from "react";
+/**
+ * Approving a sign-in that started somewhere with no browser.
+ *
+ * Drop this on a page in your own application — `/device` is the convention —
+ * and point your device's verification URI at it. The person is already signed
+ * in here, which is the whole reason this belongs in your app rather than on a
+ * page of ours: there is nothing to log into, and the page looks like yours.
+ *
+ * Two steps, deliberately. The code is checked first so that what is being
+ * approved can be named before anybody presses Approve; a single button that
+ * takes a code and grants access in one motion is a button people press without
+ * reading.
+ */
+export interface DeviceApprovalProps {
+    /**
+     * The code, when your page already has it.
+     *
+     * A device that can show a link or a QR code puts the code in the URL, which
+     * saves exactly the typing this flow exists to avoid. Read it off your router
+     * and pass it here; the entry step is skipped.
+     */
+    userCode?: string;
+    /** Called after the person answers, with what they chose. */
+    onDecided?: (approved: boolean) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function DeviceApproval({ userCode, onDecided, className, style, }: DeviceApprovalProps): import("react").JSX.Element | null;
+//# sourceMappingURL=DeviceApproval.d.ts.map

package/dist/src/DeviceApproval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceApproval.d.ts","sourceRoot":"","sources":["../../src/DeviceApproval.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAY,KAAK,aAAa,EAAkB,MAAM,OAAO,CAAC;AAKrE;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,mBAAmB;IACnC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,cAAc,CAAC,EAC9B,QAAa,EACb,SAAS,EACT,SAAS,EACT,KAAK,GACL,EAAE,mBAAmB,sCAqIrB"}

package/dist/src/ForgotPassword.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties } from "react";
+/**
+ * Asking for a reset link.
+ *
+ * The screen always says the same thing afterwards, whether or not the address
+ * has an account. That is not politeness: a form that said "no account with
+ * that address" is a way to discover who has registered, one address at a time,
+ * and the API already refuses to distinguish them — so a component that showed
+ * a different message for each would be inventing information the server
+ * deliberately withheld.
+ *
+ * There is no prop for where the link lands. That URL is configured on the
+ * environment, for the same reason a checkout return URL is — a form that could
+ * name it would be a way to have a sign-in link emailed to somewhere else.
+ */
+export interface ForgotPasswordProps {
+    onSent?: (email: string) => void;
+    /** Back to sign-in. Rendered as a link when given. */
+    signInUrl?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function ForgotPassword({ onSent, signInUrl, className, style }: ForgotPasswordProps): import("react").JSX.Element;
+//# sourceMappingURL=ForgotPassword.d.ts.map

package/dist/src/ForgotPassword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgotPassword.d.ts","sourceRoot":"","sources":["../../src/ForgotPassword.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAKrD;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,mBAAmB;IACnC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,mBAAmB,+BA8E1F"}

package/dist/src/Invoices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Invoices.d.ts","sourceRoot":"","sources":["../../src/Invoices.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAuB7E;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,+BA2G3F"}
+{"version":3,"file":"Invoices.d.ts","sourceRoot":"","sources":["../../src/Invoices.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAuB7E;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,+BAgI3F"}

package/dist/src/Kanban.d.ts

@@ -0,0 +1,40 @@
+import { type CollectionRecord } from "@base316/sdk";
+import { type CSSProperties, type ReactNode } from "react";
+import { type UseCollectionOptions } from "./useCollection";
+/**
+ * A board, over a collection that was never designed to have one.
+ *
+ * This component is the proof of the whole design. It was written after the
+ * schema and the table, it knows nothing about jobs or tickets or deals, and it
+ * asks the schema one question:
+ *
+ *     defaultGroupFieldOf(schema.fields)   // "which field makes columns?"
+ *
+ * The registry answers with the SELECT field, because a status or a stage is
+ * what somebody means by grouping — and so `<Kanban collection="jobs" />`
+ * works with no props at all. Had fields been described in rendering terms
+ * ("this column is right-aligned"), there would have been nothing here to ask,
+ * and every board would need its own configuration naming its own columns.
+ *
+ * Moving a card writes the grouping field. That is the only mutation a board
+ * makes, and it is why the field has to be one with a fixed set of values: a
+ * column header has to be a value somebody can drop onto.
+ */
+export interface KanbanProps extends UseCollectionOptions {
+    collection: string;
+    /**
+     * Which field makes the columns.
+     *
+     * Discovered when omitted. Name it when a collection has several groupable
+     * fields and the first choice is not the one this board is about.
+     */
+    groupBy?: string;
+    /** Fields to show on a card, in order. Defaults to the title and the next two. */
+    cardFields?: string[];
+    onSelect?: (record: CollectionRecord) => void;
+    emptyState?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Kanban({ collection, groupBy, cardFields, onSelect, emptyState, className, style, ...options }: KanbanProps): import("react").JSX.Element;
+//# sourceMappingURL=Kanban.d.ts.map

package/dist/src/Kanban.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Kanban.d.ts","sourceRoot":"","sources":["../../src/Kanban.tsx"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,gBAAgB,EAKrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAY,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAIrE,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,WAAY,SAAQ,oBAAoB;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9C,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,MAAM,CAAC,EACtB,UAAU,EACV,OAAO,EACP,UAAU,EACV,QAAQ,EACR,UAAU,EACV,SAAS,EACT,KAAK,EACL,GAAG,OAAO,EACV,EAAE,WAAW,+BAoMb"}

package/dist/src/PasskeyManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PasskeyManager.d.ts","sourceRoot":"","sources":["../../src/PasskeyManager.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAK7E;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAC9B,SAAS,EACT,KAAK,EACL,KAAkB,GAClB,EAAE;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,sCA+IA"}
+{"version":3,"file":"PasskeyManager.d.ts","sourceRoot":"","sources":["../../src/PasskeyManager.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAM7E;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAC9B,SAAS,EACT,KAAK,EACL,KAAkB,GAClB,EAAE;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,sCAoJA"}

package/dist/src/PayInvoice.d.ts

@@ -0,0 +1,41 @@
+import { type CSSProperties } from "react";
+interface StripeElements {
+    create(type: string): {
+        mount(selector: string | HTMLElement): void;
+    };
+}
+interface StripeLike {
+    elements(options: {
+        clientSecret: string;
+    }): StripeElements;
+    confirmPayment(options: {
+        elements: StripeElements;
+        confirmParams: {
+            return_url: string;
+        };
+        redirect: "if_required";
+    }): Promise<{
+        error?: {
+            message?: string;
+        };
+    }>;
+}
+declare global {
+    interface Window {
+        Stripe?: (key: string, options?: {
+            stripeAccount: string;
+        }) => StripeLike;
+    }
+}
+export declare function PayInvoice({ token, environmentId, onPaid, className, style, }: {
+    /** From `invoices.createPaymentLink` on your server. */
+    token: string;
+    /** The environment the link belongs to; it is in the link URL too. */
+    environmentId: string;
+    /** Runs once the payment is complete. */
+    onPaid?: () => void;
+    className?: string;
+    style?: CSSProperties;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=PayInvoice.d.ts.map

package/dist/src/PayInvoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PayInvoice.d.ts","sourceRoot":"","sources":["../../src/PayInvoice.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA+B,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AA0BxE,UAAU,cAAc;IACvB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAA;KAAE,CAAC;CACtE;AAED,UAAU,UAAU;IACnB,QAAQ,CAAC,OAAO,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc,CAAC;IAC5D,cAAc,CAAC,OAAO,EAAE;QACvB,QAAQ,EAAE,cAAc,CAAC;QACzB,aAAa,EAAE;YAAE,UAAU,EAAE,MAAM,CAAA;SAAE,CAAC;QACtC,QAAQ,EAAE,aAAa,CAAC;KACxB,GAAG,OAAO,CAAC;QAAE,KAAK,CAAC,EAAE;YAAE,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;CAC9C;AAED,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,MAAM;QACf,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;YAAE,aAAa,EAAE,MAAM,CAAA;SAAE,KAAK,UAAU,CAAC;KAC1E;CACD;AAgCD,wBAAgB,UAAU,CAAC,EAC1B,KAAK,EACL,aAAa,EACb,MAAM,EACN,SAAS,EACT,KAAK,GACL,EAAE;IACF,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,aAAa,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB,+BA8GA"}

package/dist/src/PricingTable.d.ts

@@ -1,21 +1,53 @@
 import type { PublicPlan } from "@base316/sdk";
-import { type CSSProperties } from "react";
+import type { CSSProperties } from "react";
 /**
- * The plans, as an end user picks between them.
+ * The plans, as an end user picks them.
  *
- * `onSelectPlan` is required and takes the plan version id, because this
- * component deliberately cannot start a checkout itself. Minting a checkout
- * session needs a secret key, and the plan has to be named by a server — a
- * browser that could choose its own plan would pick the cheapest one. So the
- * host application posts to its own backend, which calls
- * `POST /v1/checkout/sessions` and redirects to the URL it returns.
+ * Drop it in with no props and it works: it loads the published plans, marks
+ * the one the signed-in user is on, and completes the purchase.
+ *
+ * Choosing a plan used to be the caller's job, because minting a checkout
+ * session needs a secret key that cannot live in a browser. That is still
+ * true — but it is an argument about *key custody*, not about who names the
+ * plan. `POST /v1/me/checkout/sessions` resolves the customer from the session
+ * and reads the price from the database against the plan id, so a browser
+ * naming a cheaper plan subscribes to a cheaper plan rather than paying less
+ * for an expensive one. That is what makes this droppable.
+ *
+ * Two routes, because a subscriber and a newcomer need different things:
+ *
+ * - Already subscribed, card on file → change plan in place, prorated, no
+ *   card re-entry and no second subscription beside the first.
+ * - Otherwise → a checkout session, which is the thing that collects a card.
+ *
+ * `onSelectPlan` remains as an override for an application that wants to run
+ * its own flow — a quote, an approval step, its own backend route.
  */
-export declare function PricingTable({ onSelectPlan, currentPlanVersionId, featuredPlanKey, className, style, }: {
-    onSelectPlan: (planVersionId: string, plan: PublicPlan) => void | Promise<void>;
-    /** Marks the plan the viewer is already on. */
+export declare function PricingTable({ onSelectPlan, currentPlanVersionId, featuredPlanKey, signInUrl, className, style, }: {
+    /**
+     * Take over what "Choose" does.
+     *
+     * Optional. Without it the component completes the purchase itself, which
+     * is what most applications want.
+     */
+    onSelectPlan?: (planVersionId: string, plan: PublicPlan) => void | Promise<void>;
+    /**
+     * Marks the plan the viewer is already on.
+     *
+     * Discovered from the signed-in user's subscription when not given. Pass it
+     * to override — on a marketing page rendering someone else's plan, say.
+     */
     currentPlanVersionId?: string | null;
     /** The plan to present as the default choice, by its key. */
     featuredPlanKey?: string;
+    /**
+     * Where to send a signed-out visitor who picks a plan.
+     *
+     * Checkout needs a session, so without a signed-in user there is nobody to
+     * bill. Given a URL the button goes there; without one it says so rather
+     * than failing on click.
+     */
+    signInUrl?: string;
     className?: string;
     style?: CSSProperties;
 }): import("react").JSX.Element;

package/dist/src/PricingTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PricingTable.d.ts","sourceRoot":"","sources":["../../src/PricingTable.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AA4BhE;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAC5B,YAAY,EACZ,oBAAoB,EACpB,eAAe,EACf,SAAS,EACT,KAAK,GACL,EAAE;IACF,YAAY,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,+CAA+C;IAC/C,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB,+BAgIA"}
+{"version":3,"file":"PricingTable.d.ts","sourceRoot":"","sources":["../../src/PricingTable.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AA4B3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,EAC5B,YAAY,EACZ,oBAAoB,EACpB,eAAe,EACf,SAAS,EACT,SAAS,EACT,KAAK,GACL,EAAE;IACF;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjF;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB,+BA8JA"}

package/dist/src/PrivacyControls.d.ts

@@ -0,0 +1,28 @@
+import { type CSSProperties } from "react";
+/**
+ * Download my data, and delete my account.
+ *
+ * The two things a privacy notice promises and most products never build, so
+ * the promise gets kept by an inbox and a person doing it by hand. Both here
+ * take the signed-in user's own session, so neither needs your server to be
+ * trusted with somebody else's account.
+ *
+ * Deletion asks twice, and the second time it asks the person to type. That is
+ * not friction for its own sake: this is the one control on the page that
+ * cannot be undone, and a misplaced click should not be able to reach it.
+ */
+export interface PrivacyControlsProps {
+    /**
+     * What must be typed to confirm deletion.
+     *
+     * Defaults to the English word, which is wrong in every other language —
+     * pass the one your interface is written in.
+     */
+    confirmWord?: string;
+    /** Called after the account is gone. Sign them out and send them somewhere. */
+    onErased?: () => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function PrivacyControls({ confirmWord, onErased, className, style, }: PrivacyControlsProps): import("react").JSX.Element | null;
+//# sourceMappingURL=PrivacyControls.d.ts.map

package/dist/src/PrivacyControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrivacyControls.d.ts","sourceRoot":"","sources":["../../src/PrivacyControls.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAKrD;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,eAAe,CAAC,EAC/B,WAAsB,EACtB,QAAQ,EACR,SAAS,EACT,KAAK,GACL,EAAE,oBAAoB,sCAmItB"}

package/dist/src/RecordDetail.d.ts

@@ -0,0 +1,31 @@
+import { type CSSProperties, type ReactNode } from "react";
+/**
+ * One record, read.
+ *
+ * The other half of a table: a row shows what fits in a column, and this shows
+ * everything — including the fields a table deliberately truncates, like a
+ * paragraph of notes, and the derived ones a form leaves out because they
+ * cannot be typed.
+ *
+ *     <RecordDetail collection="jobs" recordId={id} />
+ *
+ * Edit is offered only when the viewer may write, which the schema already
+ * says. There is no second permission check here and there should not be: the
+ * server decides, and a component that decided for itself would eventually
+ * disagree with it.
+ */
+export interface RecordDetailProps {
+    collection: string;
+    recordId: string;
+    tenant?: string;
+    /** Hide Edit and Delete even for a viewer who may write. */
+    readOnly?: boolean;
+    onDeleted?: () => void;
+    onClose?: () => void;
+    /** Rendered under the fields — related lists, actions, anything. */
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function RecordDetail({ collection, recordId, tenant, readOnly, onDeleted, onClose, children, className, style, }: RecordDetailProps): import("react").JSX.Element;
+//# sourceMappingURL=RecordDetail.d.ts.map

package/dist/src/RecordDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordDetail.d.ts","sourceRoot":"","sources":["../../src/RecordDetail.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAY,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAQrE;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,iBAAiB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,YAAY,CAAC,EAC5B,UAAU,EACV,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,SAAS,EACT,OAAO,EACP,QAAQ,EACR,SAAS,EACT,KAAK,GACL,EAAE,iBAAiB,+BAqHnB"}

package/dist/src/RecordForm.d.ts

@@ -0,0 +1,32 @@
+import { type FieldValue } from "@base316/sdk";
+import { type CSSProperties } from "react";
+/**
+ * Creating or editing one record, with the form derived from the schema.
+ *
+ * Nobody writes the inputs. The field types decide which control each value
+ * gets, which ones are required, and which are not editable at all — an
+ * AUTONUMBER, a LOOKUP and a ROLLUP are produced by the server, so offering an
+ * input for one would invite somebody to type a value that is discarded.
+ *
+ *     <RecordForm collection="jobs" />                 // create
+ *     <RecordForm collection="jobs" recordId={id} />   // edit
+ *
+ * Errors come back per field and land under the input that caused them.
+ * Validation is not repeated here: the same `validateRecord` the server uses
+ * would have to be kept in step, and a second implementation that drifts is
+ * worse than one round trip.
+ */
+export interface RecordFormProps {
+    collection: string;
+    /** Omit to create. */
+    recordId?: string;
+    tenant?: string;
+    onSaved?: (id: string) => void;
+    onCancel?: () => void;
+    /** Start with these values filled in. Ignored when editing. */
+    defaults?: Record<string, FieldValue>;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function RecordForm({ collection, recordId, tenant, onSaved, onCancel, defaults, className, style, }: RecordFormProps): import("react").JSX.Element;
+//# sourceMappingURL=RecordForm.d.ts.map

package/dist/src/RecordForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordForm.d.ts","sourceRoot":"","sources":["../../src/RecordForm.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAW,MAAM,cAAc,CAAC;AACxD,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAOhE;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,UAAU,CAAC,EAC1B,UAAU,EACV,QAAQ,EACR,MAAM,EACN,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,KAAK,GACL,EAAE,eAAe,+BA+GjB"}

package/dist/src/RelationPicker.d.ts

@@ -0,0 +1,23 @@
+import type { FieldDescriptor } from "@base316/sdk";
+/**
+ * Choosing a record in another collection, by typing its name.
+ *
+ * The alternative is a text box holding an id, which nobody can fill in
+ * without going to look one up — so a relation field without this is a
+ * relation field nobody uses.
+ *
+ * Two fetches, and they answer different questions. The title of what is
+ * already chosen has to be known before anybody types, or an existing record
+ * opens showing an id. The search results are what typing produces. Conflating
+ * them means an edit form that looks empty until the user searches for the
+ * value it already has.
+ */
+export declare function RelationPicker({ field, value, onChange, error, disabled, tenant, }: {
+    field: FieldDescriptor;
+    value: string | null;
+    onChange: (value: string | null) => void;
+    error?: string | null;
+    disabled?: boolean;
+    tenant?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=RelationPicker.d.ts.map

package/dist/src/RelationPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationPicker.d.ts","sourceRoot":"","sources":["../../src/RelationPicker.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAKpD;;;;;;;;;;;;GAYG;AAEH,wBAAgB,cAAc,CAAC,EAC9B,KAAK,EACL,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,MAAM,GACN,EAAE;IACF,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,+BAqLA"}

package/dist/src/ResetPassword.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties } from "react";
+/**
+ * Setting a new password from an emailed link.
+ *
+ * The page the link lands on renders this; the token comes from `?token=` and
+ * is removed from the address bar as soon as it is read. A reset token sitting
+ * in browser history, in a referrer header or in a shared screenshot is a way
+ * into the account for as long as it is unspent.
+ *
+ * The confirmation field is checked here rather than by the server, because it
+ * is the one thing the server cannot help with: two different strings are both
+ * valid passwords, and only the person typing knows which they meant.
+ */
+export interface ResetPasswordProps {
+    /** Supply the token directly. Read from `?token=` when omitted. */
+    token?: string;
+    onReset?: () => void;
+    /** Where to go afterwards. Rendered as a link when given. */
+    signInUrl?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function ResetPassword({ token: supplied, onReset, signInUrl, className, style, }: ResetPasswordProps): import("react").JSX.Element;
+//# sourceMappingURL=ResetPassword.d.ts.map

package/dist/src/ResetPassword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResetPassword.d.ts","sourceRoot":"","sources":["../../src/ResetPassword.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAKhE;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,kBAAkB;IAClC,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,aAAa,CAAC,EAC7B,KAAK,EAAE,QAAQ,EACf,OAAO,EACP,SAAS,EACT,SAAS,EACT,KAAK,GACL,EAAE,kBAAkB,+BA+HpB"}