@nanisoft/prism-ui 0.10.2 → 0.15.0

package/dist/blocks/field-map-01/field-map.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { Section, SectionHeading } from '../../components/ui/section.js';
+import { Status } from '../../components/ui/status.js';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from '../../components/ui/table.js';
+import { cn } from '../../lib/utils.js';
+/**
+ * The tone each state is drawn in, from the semantic contract and no other.
+ *
+ * `mapped` is `success` because it is the one state that means the work is done.
+ * `unmapped` is `warning` rather than `destructive` on purpose: an unmapped field
+ * is a thing to do, not a fault, and a table of thirty rows where four are amber
+ * is a table with four tasks in it, while the same four in red reads as four
+ * breakages and sends a reader looking for an incident that is not happening.
+ * `transformed` is `info`, which is the contract's cool role that means not an
+ * alarm, and `excluded` is `neutral`, because a field somebody chose to leave
+ * behind is not in dispute and must not be drawn as though it were.
+ */
+const STATE_TONE = {
+    mapped: 'success',
+    unmapped: 'warning',
+    transformed: 'info',
+    excluded: 'neutral',
+};
+/**
+ * The layout each detail column gets when the caller says nothing.
+ *
+ * Only the two prose columns are told to wrap, and the reason is that the
+ * component they come from sets every cell to `whitespace-nowrap` so a table of
+ * numbers lines up. A transformation is a sentence and a note is a sentence, and
+ * a table that scrolls a sentence sideways to keep it on one line is a table
+ * nobody reads a whole row of. The three short columns keep the default, because
+ * a required mark, a type name and a state are all things that are better on one
+ * line than wrapped across two.
+ */
+const COLUMN_CELL = {
+    required: '',
+    type: '',
+    transform: 'whitespace-normal',
+    state: '',
+    note: 'whitespace-normal',
+};
+/**
+ * A source-to-target field mapping: what a field is called on one side, what it
+ * becomes on the other, whether it is required, what type it is, and what has to
+ * happen to the value.
+ *
+ * **This is the artefact a pipeline and an estate both produce, and it is why the
+ * Block is a Block rather than a component.** A component is a control with one
+ * job. This is a section: a heading, a paragraph of why the table is here, and a
+ * document a reader works down row by row, and it composes `Section`,
+ * `SectionHeading`, `Status` and the `Table` parts. A consumer whose data is a
+ * mapping and a consumer whose data is a data dictionary are drawing the same
+ * table, and the difference between their two tables is the names in two cells.
+ *
+ * **The two system names are required together, and the reason is that the two
+ * columns are the two systems.** A mapping table's whole content is the
+ * correspondence between one named thing and another, and a header that says
+ * "Source" on the left and "Destination" on the right has thrown both names away
+ * and replaced them with the shape of the operation. That table is not useless,
+ * it is worse than useless, because it reads correctly in the deployment where
+ * the two systems happen to be obvious and is misread in every deployment where
+ * they are not, and nobody catches it because the table looks finished. A reader
+ * holding "Customer__c" on the left and "buyer_ref" on the right, with no system
+ * named, has to guess which way the migration runs, and a migration run backwards
+ * is the single most expensive mistake this document can cause. So the Block asks
+ * for both names, asks for them together, and refuses one without the other: a
+ * table with a source name and a generic destination name is the half-answered
+ * case, and it is worse than a compile error because it renders. Prism will not
+ * name either system itself, because Prism does not know whether the consumer is
+ * moving from a CRM into a warehouse or out of one into a CRM, and printing the
+ * wrong pair in the other direction would be a confident answer to a question it
+ * cannot see.
+ *
+ * **The four states use the `Status` tones, and the words are the caller's
+ * through a required `stateLabel`.** Out loud, because a caller choosing a state
+ * needs to know what the colours mean before they choose: `mapped` lands in the
+ * target under the same name and is drawn `success`, `unmapped` has no
+ * counterpart there yet and is drawn `warning`, `transformed` lands under a
+ * different name or in a different shape and is drawn `info`, and `excluded` was
+ * deliberately left behind and is drawn `neutral`. Every one of those dots is
+ * `aria-hidden` and the words beside it are not, so a reader who cannot separate
+ * `warning` from `destructive` still reads which is which, which is also why the
+ * state list can stay as small as it is. `stateLabel` takes the field's name as
+ * well as the state, because a mapping table is read one row at a time and a
+ * reader who has navigated to a cell needs to know which field they are in, and
+ * because the honest sentence is per row in most of them: "not carried across",
+ * "renamed on the way in", "held back pending a decision about the buyer".
+ *
+ * **A row with no target renders the caller's `unmappedLabel`, and that is the
+ * decision this Block is most particular about.** The obvious thing in an empty
+ * table cell is a dash, and the dash is wrong here for a reason that has nothing
+ * to do with taste. A mapping table is a document somebody acts on: it is the
+ * thing an engineer reads before a migration and a reviewer reads during one, and
+ * a field with no counterpart is a task, not an absence. An em dash says the
+ * author had nothing to say, and the reader who believes it files the row as done.
+ * The caller's own words say what the row actually is, which is either a thing
+ * still to be done or a decision already taken, and those are opposite actions on
+ * the same empty cell. A slot rather than a string, because the two sentences are
+ * not variants of one.
+ *
+ * **The two system columns are not in `columns`, and that is a closed set rather
+ * than an omission.** `columns` names the caller's own headings for the rest of
+ * the table and the order they are read in, which is genuinely the caller's
+ * decision. The two system headings are not, because the Block already has them
+ * in `sourceLabel` and `targetLabel` and a list that could also name them would
+ * be a list with two entries the table ignores. A caller who has to look at a
+ * list and ask which of its entries is being dropped has been handed a list that
+ * does not describe the thing, and the type here is how that is prevented rather
+ * than a comment asking them to be careful.
+ *
+ * **It is a real table, and that is the accessibility claim.** The header cells
+ * are `<th scope="col">` and the field name is a `<th scope="row">`, so a reader
+ * navigating by cell hears which column and which field every value belongs to,
+ * and a reader moving by row hears the field before the values under it. The
+ * alternative was a grid of `div`s with `role="presentation"` and a caption, and
+ * it is the arrangement most hand-written mapping tables use, because it is easier
+ * to make responsive. What it costs is that the correspondence between a value
+ * and its field is then a position, and a position is the one thing a screen
+ * reader, a crawler and a print stylesheet cannot read.
+ *
+ * It is a server Component: no hook, no state, no client code and no router. The
+ * table is markup, so a mapping document costs a consumer nothing in client
+ * JavaScript and reads identically with scripting off.
+ */
+export function FieldMap01({ eyebrow, title, description, columns, rows, sourceLabel, targetLabel, stateLabel, requiredLabel, unmappedLabel, headingLevel = 'h2', className, }) {
+    // The handle a table below takes its name from; see the note on the table.
+    const headingId = useId();
+    if (!sourceLabel || !targetLabel) {
+        throw new Error('FieldMap01: one of the two system names was not passed, so one of the two columns would carry a ' +
+            'generic heading over a table whose whole content is the correspondence between two named ' +
+            'systems. Pass the name of the source and the name of the target, together.');
+    }
+    if (rows.length === 0)
+        return null;
+    /**
+     * The cell one column draws for one row.
+     *
+     * A switch rather than a map of render functions, because a map keyed by
+     * column id would be a second recipe of the kind this package keeps off the
+     * public surface, and a switch over five cases is the same table with the
+     * strings in the same file as the drawing that uses them.
+     */
+    function cellOf(id, row) {
+        switch (id) {
+            case 'required':
+                if (row.required === undefined)
+                    return null;
+                return (_jsx(Status, { size: "sm", tone: row.required ? 'info' : 'neutral', label: requiredLabel(row.required) }));
+            case 'type':
+                return row.type === undefined ? null : _jsx("span", { className: "font-mono text-xs", children: row.type });
+            case 'transform':
+                return row.transform ?? null;
+            case 'state': {
+                const state = stateOf(row);
+                return _jsx(Status, { size: "sm", tone: STATE_TONE[state], label: stateLabel(state, row.source) });
+            }
+            case 'note':
+                return row.note ?? null;
+        }
+    }
+    return (_jsxs(Section, { children: [_jsx(SectionHeading, { as: headingLevel, id: headingId, align: "left", eyebrow: eyebrow, title: title, description: description, className: "mb-10" }), _jsx("div", { "data-slot": "field-map", className: cn('border-border rounded-xl border', className), children: _jsxs(Table, { "aria-labelledby": headingId, children: [_jsx(TableHeader, { children: _jsxs(TableRow, { children: [_jsx(TableHead, { scope: "col", children: sourceLabel }), _jsx(TableHead, { scope: "col", children: targetLabel }), columns.map((column) => (_jsx(TableHead, { scope: "col", className: column.className, children: column.header }, column.id)))] }) }), _jsx(TableBody, { children: rows.map((row) => (_jsxs(TableRow, { "data-slot": "field-map-row", "data-state": stateOf(row), children: [_jsx(TableHead, { scope: "row", className: "font-mono text-xs font-medium", children: row.source }), _jsx(TableCell, { className: "font-mono text-xs", children: row.target ?? (_jsx("span", { "data-slot": "field-map-unmapped", className: "text-muted-foreground font-sans", children: unmappedLabel })) }), columns.map((column) => (_jsx(TableCell, { className: cn(COLUMN_CELL[column.id], column.className), children: cellOf(column.id, row) }, column.id)))] }, row.id))) })] }) })] }));
+}
+/**
+ * The state a row is in when the caller did not say.
+ *
+ * A restatement of the row's own data rather than a judgement about it: a field
+ * with a target name has been mapped, and a field without one has not. That is
+ * why the derivation is safe to make, and it is why the two states it produces
+ * are the two the data itself settles. It is not safe for the other two, which is
+ * the whole reason `state` exists: a transformation is invisible in the data,
+ * because a field called `close_date` in one system and `closed_at` in the other
+ * looks exactly like a rename until somebody says it, and a field that was
+ * deliberately not carried across looks exactly like one somebody forgot. Both
+ * have to be stated, and a Block that inferred either would be inventing a
+ * decision on the reader's behalf.
+ */
+function stateOf(row) {
+    if (row.state !== undefined)
+        return row.state;
+    return row.target === undefined ? 'unmapped' : 'mapped';
+}
+export default FieldMap01;

package/dist/blocks/field-map-01/index.d.ts

@@ -0,0 +1,3 @@
+export { FieldMap01, default } from './field-map.js';
+export type { FieldMap01Props, FieldMapColumn, FieldMapColumnId, FieldMapRow, FieldMapState } from './field-map.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blocks/field-map-01/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blocks/field-map-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAMjD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/dist/blocks/field-map-01/index.js

@@ -0,0 +1 @@
+export { FieldMap01, default } from './field-map.js';

package/dist/blocks/forgot-password-01/forgot-password.d.ts

@@ -0,0 +1,288 @@
+import { type ReactNode } from 'react';
+import { type HeadingLevel } from '../../components/ui/section.js';
+/**
+ * The thing the reader types to say which account they mean, declared by the caller.
+ *
+ * The same shape `Login01` takes and the same argument: a product that identifies a
+ * person by an address and a product that identifies an operator by a handle or a
+ * staff number both need the same labelled text control, and the words above it are
+ * the product's own claim about what identifies a person there. `autoComplete` is
+ * deliberately not defaulted here either, because the hint a password manager wants
+ * is a fact about the identifier rather than about this screen, and the type a
+ * platform can do something different with is `email` on most of these products and
+ * `text` on the rest.
+ */
+export type ForgotPassword01Identifier = {
+    /** The field's visible name, and the accessible name its control announces. */
+    label: string;
+    /**
+     * Which of the two the platform's own behaviour differs on.
+     *
+     * `email` turns up a different keypad on a phone and lets a browser offer the
+     * address it already knows; `text` is right for a handle and for a workspace name.
+     */
+    type?: 'email' | 'text';
+    /** The platform's autofill hint, when the identifier is not an address. */
+    autoComplete?: string;
+    /**
+     * A line under the control, announced with it rather than printed under the row.
+     *
+     * A node, because the honest line in this position is often a sentence naming the
+     * accounts this product can recover, and a caller who has to flatten theirs to a
+     * string loses it.
+     */
+    description?: ReactNode;
+    /** The identifier as the caller holds it. Refused without `onValueChange`. */
+    value?: string;
+    /** Called with the identifier as the reader changes it. */
+    onValueChange?: (value: string) => void;
+};
+/**
+ * The three things the caller's own recovery request can be doing, named after what
+ * they select rather than after the field they fill.
+ *
+ * `idle` is the form at rest and `error` is the one refusal this Block is willing to
+ * hear about, which is a refusal of the request itself: a transport that could not
+ * be reached, a rate limit the caller owns, a captcha that would not pass. It is not
+ * a statement about the account, and that is the decision the whole Block is shaped
+ * by. `sent` is the machine value for the announcement that the request was taken,
+ * and it deliberately carries no claim that a message is on its way to an address
+ * that exists.
+ */
+export type ForgotPassword01Outcome = 'idle' | 'sent' | 'error';
+/**
+ * The outcome of the caller's own request, as this Block draws it.
+ *
+ * A prop and never a state this Block writes, for the reason every Block in this
+ * family states: there is no sentence anywhere in this file, and the sentence this
+ * screen most needs is the one a design system has no business writing.
+ */
+export type ForgotPassword01Status = {
+    /** Which of the three the request is in. Read by the Block for two things only. */
+    state: ForgotPassword01Outcome;
+    /** The words for that state, in the product's own voice. */
+    message: ReactNode;
+};
+/** What the confirmation arm carries, and the union is what makes the pair mean one thing. */
+export type ForgotPassword01Sent = {
+    /**
+     * The confirmation itself.
+     *
+     * **Required, and the whole of the decision this Block is named for.** It is the
+     * caller's sentence and it is not this Block's job to check that the caller wrote
+     * the same one in both cases, because that check is the Block asserting it knows
+     * whether an account was found. What the Block does instead is hold no prop that
+     * could carry the fact, so the leak cannot be expressed in the interface at all.
+     * See the Block's JSDoc for the trade in both directions.
+     */
+    message: ReactNode;
+} & ({
+    /** The words on the control that sends the request again. */
+    resendLabel: string;
+    /** Called when the reader asks for the request to be sent again. */
+    onResend: () => void;
+} | {
+    /** A resend control with no words is a button nobody can find. */
+    resendLabel?: never;
+    /** A handler with no control is a call the caller cannot make. */
+    onResend?: never;
+});
+/**
+ * One way off this screen, and where it goes.
+ *
+ * A sentence and not a noun phrase, for the argument `Login01Link` gives: a link
+ * whose visible words do not say what activating it does is a link a voice control
+ * user cannot speak, because the words they can see are the words they can say.
+ */
+export type ForgotPassword01Link = {
+    /** The words on the link, and its accessible name. */
+    label: string;
+    /** The destination, in the `href` where the status bar and the context menu reach it. */
+    href: string;
+};
+/**
+ * The props a ForgotPassword01 takes. Every string in this Block is one of them.
+ *
+ * There is no field list here and that is the design rather than an omission. A
+ * recovery form that could ask for a second identifier has already decided something
+ * about the caller's product, and the one thing it must not do is decide whether the
+ * first one was right.
+ */
+export type ForgotPassword01Props = {
+    /** The short line above the title, usually which product this is. */
+    eyebrow?: ReactNode;
+    /**
+     * The heading.
+     *
+     * Required, because a credential surface with no heading is a form in a page, and
+     * a reader who cannot get in deserves to be told which product refused them before
+     * they type anything personal into it.
+     */
+    title: ReactNode;
+    /**
+     * What is about to happen to the identifier.
+     *
+     * **Required, and the difference from every other Block's description is the fact
+     * rather than an inconsistency.** A product page can omit a description and the
+     * omission is a design choice. This screen cannot: the reader has just discovered
+     * they cannot get in, they are about to type the one datum that ties them to an
+     * account, and the confirmation that follows is deliberately the same whether or
+     * not the account exists. That leaves the frame as the only place left to say what
+     * is about to happen, so a description this Block can ship without would be a
+     * screen where a reader who mistyped their address is told nothing at all, for
+     * ever, and concludes the message went somewhere. What the description says is the
+     * caller's, because what happens to an address in their product is their fact.
+     */
+    description: ReactNode;
+    /**
+     * Called with the identifier, and the only thing this Block does with it.
+     *
+     * **Required, and the requirement is the whole of the Block's neutrality.** There
+     * is no transport here, no route, no mail queue and no session store, because each
+     * of those is a decision about the caller's product and its data, and a frame that
+     * takes one is a frame that has to be replaced rather than configured.
+     */
+    onSubmit: (value: {
+        identifier: string;
+    }) => void;
+    /** The identifier field, declared by the caller. See `ForgotPassword01Identifier`. */
+    identifier: ForgotPassword01Identifier;
+    /** The words on the one control that submits. */
+    submitLabel: string;
+    /**
+     * Whether the caller's request is in flight.
+     *
+     * A prop and not read from `status`, because the two answer different questions:
+     * `submitting` is the control and `status.state` is the outcome. It covers a resend
+     * as well as the first request, because from where the reader is sitting the two
+     * are the same request and the one control on screen should be the one that goes
+     * quiet.
+     */
+    submitting?: boolean;
+    /**
+     * The outcome of the caller's request, drawn in a live region and announced.
+     *
+     * Drawn in both arms, which is why it is a separate prop from `sent`: the
+     * announcement is needed while the form is up and after it is replaced, and the
+     * confirmation is needed in only one of them. A single object would force a caller
+     * to invent a confirmation sentence for a form that is still on the screen.
+     *
+     * **A caller that passes `sent` normally passes no `status`, and that is the rule
+     * rather than an oversight.** The arm has already said the outcome, in
+     * `sent.message`, and putting the same sentence in both would draw it twice on the
+     * one screen where a reader is reading it for the only time. `status` is for
+     * everything after the first press: a resend that was refused, or a resend whose
+     * second sentence is worth saying.
+     */
+    status?: ForgotPassword01Status;
+    /**
+     * The arm that replaces the form.
+     *
+     * Passing it takes the identifier field and the submit control away and draws the
+     * caller's confirmation in their place. **There is no field in this type that says
+     * whether an account was found**, and the absence is the design; see the Block's
+     * JSDoc for the argument in both directions.
+     */
+    sent?: ForgotPassword01Sent;
+    /** The link that leaves this screen without recovering anything. */
+    back?: ForgotPassword01Link;
+    /** Heading level for the section heading. @defaultValue 'h2' */
+    headingLevel?: HeadingLevel;
+    /**
+     * Layout only, exactly as on every Block. Changing a Prism-owned visual property
+     * from here is prohibited.
+     */
+    className?: string;
+};
+/**
+ * One identifier, one control, and a confirmation that says the same thing whether or
+ * not the account exists.
+ *
+ * **The translation, because the pattern is not ours and the framing is.** A
+ * storefront publishes a forgot-password card: an address field, one button, and a
+ * line that says to check your inbox, and its purpose is to get a shopper past a
+ * locked door so their order history is waiting on the other side. Prism's products
+ * observe a pipeline, capture a market, watch an estate and run agents, and a machine
+ * acting on behalf of a person is the whole subject, so this is the screen where
+ * somebody who is responsible for an instrument asks for a way back in to it. The
+ * composition is the storefront's and is deliberately unchanged: one labelled field,
+ * one control, one outcome line, one way off the screen. What is different is the
+ * sentence after the press, and the rest of this note is about that sentence.
+ *
+ * **What it assumes about the reader in front of it, because a recovery flow that
+ * assumes a careful reader is a flow that fails the one time it is needed.** It
+ * assumes the reader cannot get in, that they are often in a hurry, and that they
+ * may be on a machine they do not fully control. It assumes nothing about the state
+ * of their account, nothing about whether they know their own address by heart, and
+ * nothing about whether they will read the frame. It refuses to assume they typed
+ * correctly, because the whole design exists to make that assumption unnecessary.
+ *
+ * **The decision that makes this a separate Item from `contact-01` is that the
+ * confirmation is the same whether or not the account exists, and it is expressed in
+ * the shape rather than in the prose.** There is no `found` flag, no `unknown`, no
+ * `registered` and no second message. `sent.message` is one sentence, and the type
+ * has nowhere to put a second one. The alternative was a `status` that grew an arm
+ * for the negative case, which is a two-line change to the props and a permanent
+ * capability to leak in every product that installs this Block, and a leak that is
+ * cheap to add and expensive to remove once a product's support process depends on
+ * it.
+ *
+ * **The trade is real and it is argued in both directions, because it is not a
+ * clean win.** A message that differs leaks which addresses are registered, and that
+ * is an enumeration oracle: an attacker with any address list learns which of them
+ * hold an account here, and a reader with a mistyped address learns the same thing
+ * about themselves. A message that is identical teaches the reader that a mistyped
+ * address succeeded, and it is the version that is more often wrong in practice,
+ * because a recovery form is the one form a reader is most likely to fill from memory
+ * and most likely to get wrong. Both sentences are true. The resolution that does
+ * not pick a side is a confirmation that names the next step without confirming the
+ * account: it says what has been sent and where to look, and it does not say what was
+ * found. That is a sentence the caller's product can write in a way that is true of
+ * both cases, and it is the reason `sent.message` is a node and the whole of what the
+ * arm carries. **The words are the caller's.** A consumer that wants the other trade
+ * can write it in `sent.message` and the Block will not stop them, because the Block
+ * has no opinion about a disclosure decision; what it does is refuse to make the
+ * choice on their behalf by refusing to have a place to put it.
+ *
+ * **`status` and `sent` are two props because they answer two questions.** `status`
+ * is the announcement, and it is needed while the form is up and after it is
+ * replaced: a caller whose transport failed on the first press and then succeeded on
+ * the second needs a region in both arms. `sent` is the arm, and passing it is what
+ * takes the field and the control away. Merging them would force a caller to invent a
+ * confirmation sentence for a form that is still on the screen, which is the shape
+ * that makes designers add a placeholder they then ship. The corollary is the rule
+ * above: the arm reports the first press, and `status` reports everything after it,
+ * so the two never carry the same sentence and the reader never reads it twice.
+ *
+ * **The card stays and the form inside it is replaced, so the reader's page does not
+ * change size under them at the moment they are reading the one line that matters.**
+ * A recovery screen that reflows on success looks like a fault, and the reader who
+ * has just mistyped their address is the reader least able to tell a reflow from a
+ * failure.
+ *
+ * **The Block owns one string and hands it over, and it validates nothing.** There
+ * is no address format check, no rate limit, no redirect to a "did you mean" page and
+ * no enumeration defence beyond the shape of the confirmation, because each of those
+ * is a decision about the caller's product and its data. What the Block does about
+ * the request is the one thing that is rendering rather than policy: it refuses a
+ * second press while `submitting` is true, because a second press is a second message
+ * queued into somebody's inbox that nobody asked for.
+ *
+ * **There is no `Alert` in this file, and the alternative was a callout with
+ * `role="alert"` beside the live region.** That announces the same sentence twice, and
+ * on a screen where a reader is waiting for an answer about whether they can get in,
+ * a doubled announcement is the one place it is least forgivable. So the outcome is
+ * a `LiveRegion` whose politeness follows the caller's own state, and `assertive`
+ * only for the refusal.
+ *
+ * It is a client Component, and the directive is unconditional. `onSubmit` is a
+ * function, a function is a piece of state, and state is a client module: a server
+ * Component cannot hand an event handler to a `<form>`, so a caller rendering this
+ * from a server Component gets a form that submits and calls nothing. The cost is
+ * that the whole module is in the client graph even where a consumer never presses
+ * the button, and the price was judged worth paying for one boundary rather than
+ * two arrangements of the same screen.
+ */
+export declare function ForgotPassword01({ eyebrow, title, description, onSubmit, identifier, submitLabel, submitting, status, sent, back, headingLevel, className, }: ForgotPassword01Props): import("react").JSX.Element;
+export default ForgotPassword01;
+//# sourceMappingURL=forgot-password.d.ts.map

package/dist/blocks/forgot-password-01/forgot-password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forgot-password.d.ts","sourceRoot":"","sources":["../../../src/blocks/forgot-password-01/forgot-password.tsx"],"names":[],"mappings":"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"}