@picked/svelte 0.0.1-dev.1789541668638 → 0.0.1-dev.1793756239746

package/dist/plugins/devtools/components/AdaptedToolHost.svelte

@@ -22,7 +22,7 @@
   /**
    * Records a tool render failure: surfaces a banner and logs to the console. A consumer tool's
    * render failure is deliberately not routed through the client event bus, so a third-party tool
-   * bug never reaches the platform's Sentry exception stream.
+   * bug never reaches the platform's exception telemetry.
    *
    * @param {unknown} error - The error thrown or rejected by the framework renderer.
    * @example
@@ -30,7 +30,7 @@
    */
   function handleRenderError(error: unknown) {
     renderFailed = true
-    // eslint-disable-next-line no-console -- surface tool failures locally; consumer errors must not reach Sentry
+    // eslint-disable-next-line no-console -- surface tool failures locally; consumer errors must not reach platform telemetry
     console.error(`Custom devtools tool "${tool.label}" failed to render`, error)
   }
 

package/dist/plugins/devtools/constants.d.ts

@@ -0,0 +1,5 @@
+/** @file Names the devtools plugin and its experience are registered under. */
+/** Plugin name under which the devtools plugin stores its config (including registered custom tools). */
+export declare const DEVTOOLS_PLUGIN_NAME = "svelte-devtools";
+/** Key of the code-defined devtools experience; the journey views never list it. */
+export declare const DEVTOOLS_EXPERIENCE_KEY = "devtools";

package/dist/plugins/devtools/constants.js

@@ -0,0 +1 @@
+var e=`svelte-devtools`,t=`devtools`;export{t as DEVTOOLS_EXPERIENCE_KEY,e as DEVTOOLS_PLUGIN_NAME};

package/dist/plugins/devtools/customTools.d.ts

@@ -1,7 +1,16 @@
-/** @file Registry helpers for the devtools "Custom Tools" tab — user-supplied, framework-adapted dev tools. */
+/** @file Registry helpers for devtools custom tools — user-supplied, framework-adapted tools. */
 import type { AdaptedComponent, Picked } from '@picked/client';
+/** Where a custom tool is listed in the devtools sidebar. */
+export type CustomToolPlacement = 'review' | 'developer';
+/** How to use steps for a custom tool, listed under the tool's label. */
+export interface CustomToolGuide {
+    /** Numbered steps, in order. `**text**` marks a control's label. */
+    steps: readonly string[];
+    /** Short lines after the steps. */
+    notes?: readonly string[];
+}
 /**
- * A user-defined developer tool surfaced under the devtools "Custom Tools" tab.
+ * A user-defined tool surfaced in the devtools sidebar.
  *
  * The component is framework-adapted (via `adaptReactComponent` or `adaptSvelteComponent`), so
  * tools can be authored in the host app's framework and still receive the live Picked client the
@@ -11,17 +20,44 @@ export interface CustomTool {
     id: string;
     label: string;
     component: AdaptedComponent;
+    /**
+     * `'review'` lists the tool as a tab of its own, beside the review tabs. `'developer'` lists it
+     * under the Developer group's Custom Tools screen.
+     *
+     * @default 'developer'
+     */
+    placement?: CustomToolPlacement;
+    /** One sentence on what the tool is for, shown above it. */
+    description?: string;
+    /** How to use steps for the tool. Listed only for a `'review'` tool. */
+    guide?: CustomToolGuide;
 }
 /**
  * Reads the custom tools registered with the devtools plugin for a given client.
  *
  * Malformed entries are dropped, and entries that repeat an already-seen `id` are dropped
- * (first registration wins), so a single bad or duplicate registration can't break the tab — the
- * `id` is used as a keyed-each key when the tools are rendered as tabs.
+ * (first registration wins), so a single bad or duplicate registration can't break the sidebar —
+ * the `id` is used as a keyed-each key when the tools are rendered.
  *
- * @param {Picked} client - The Picked client whose plugin config holds the registered tools.
+ * @param {Pick<Picked, 'getPluginConfig'>} client - The client whose plugin config holds the registered tools.
  * @returns {CustomTool[]} The valid, id-unique registered custom tools, or an empty array when none exist.
  * @example
  * const tools = readCustomTools(getPicked())
  */
-export declare function readCustomTools(client: Picked): CustomTool[];
+export declare function readCustomTools(client: Pick<Picked, 'getPluginConfig'>): CustomTool[];
+/**
+ * The tools listed as tabs of their own, beside the review tabs.
+ *
+ * @param {readonly CustomTool[]} tools - The registered tools.
+ * @returns {CustomTool[]} The tools placed `'review'`, in registration order.
+ * @example reviewTools(readCustomTools(client))
+ */
+export declare function reviewTools(tools: readonly CustomTool[]): CustomTool[];
+/**
+ * The tools listed under the Developer group's Custom Tools screen.
+ *
+ * @param {readonly CustomTool[]} tools - The registered tools.
+ * @returns {CustomTool[]} Every tool not placed `'review'`, in registration order.
+ * @example developerTools(readCustomTools(client))
+ */
+export declare function developerTools(tools: readonly CustomTool[]): CustomTool[];

package/dist/plugins/devtools/customTools.js

@@ -1 +1 @@
-import{DEVTOOLS_PLUGIN_NAME as e}from"./plugin.js";function t(e){return typeof e==`object`&&!!e&&`frameworkName`in e&&typeof e.frameworkName==`string`&&`component`in e}function n(e){return typeof e==`object`&&!!e&&`id`in e&&typeof e.id==`string`&&`label`in e&&typeof e.label==`string`&&`component`in e&&t(e.component)}function r(t){let r=t.getPluginConfig(e).customTools;if(!Array.isArray(r))return[];let i=new Set;return r.filter(n).filter(e=>!i.has(e.id)&&(i.add(e.id),!0))}export{r as readCustomTools};
+import{DEVTOOLS_PLUGIN_NAME as e}from"./constants.js";function t(e){return typeof e==`object`&&!!e}function n(e){return t(e)&&`frameworkName`in e&&typeof e.frameworkName==`string`&&`component`in e}function r(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function i(e){if(t(e)&&r(e.steps))return r(e.notes)?{steps:e.steps,notes:e.notes}:{steps:e.steps}}function a(e){if(!t(e))return null;let{id:r,label:a,component:o,placement:s,description:c,guide:l}=e;if(typeof r!=`string`||typeof a!=`string`||!n(o))return null;let u={id:r,label:a,component:o};(s===`review`||s===`developer`)&&(u.placement=s),typeof c==`string`&&(u.description=c);let d=i(l);return d&&(u.guide=d),u}function o(t){let n=t.getPluginConfig(e).customTools;if(!Array.isArray(n))return[];let r=new Set;return n.map(a).filter(e=>e!==null).filter(e=>!r.has(e.id)&&(r.add(e.id),!0))}function s(e){return e.filter(e=>e.placement===`review`)}function c(e){return e.filter(e=>e.placement!==`review`)}export{c as developerTools,o as readCustomTools,s as reviewTools};

package/dist/plugins/devtools/derive/answer-display/answer-display.d.ts

@@ -0,0 +1,112 @@
+/** How an answer is shown and edited. `system` is read-only. */
+export type AnswerKind = 'options' | 'boolean' | 'text' | 'number' | 'system';
+/** The slice of a registered field this module reads. */
+export interface AnswerField {
+    key: string;
+    name?: string;
+    label?: string;
+    type: 'text' | 'number' | 'object' | 'boolean';
+    multiple: boolean;
+    options?: readonly {
+        value: unknown;
+        label: string;
+    }[] | null;
+}
+/** Everything a row of the Answers panel needs about one answer. */
+export interface AnswerView {
+    /** The question as the customer met it. */
+    title: string;
+    /** The short noun, for a summary line where the question is too long. */
+    noun: string;
+    kind: AnswerKind;
+    /** What the answer reads as. `null` when nothing has been answered. */
+    display: string | null;
+    answered: boolean;
+    /** False for `system` answers, which are changed on their own screen. */
+    editable: boolean;
+}
+/**
+ * The short noun for a field, for summary lines and logic sentences.
+ *
+ * @param {AnswerField} field - The field.
+ * @returns {string} The field's name, or its de-slugged key.
+ * @example
+ * nounOf({ key: 'purpose', name: 'Purpose', type: 'text', multiple: false }) // 'Purpose'
+ */
+export declare function nounOf(field: AnswerField): string;
+/**
+ * The question the customer was asked, falling back through the noun to the key.
+ *
+ * @param {AnswerField} field - The field.
+ * @returns {string} The field's label, name or de-slugged key.
+ * @example
+ * questionOf({ key: 'postcode', label: 'What is your postcode?', type: 'text', multiple: false })
+ */
+export declare function questionOf(field: AnswerField): string;
+/**
+ * Classifies a field by how its answer is shown and edited. An object field is `system` whatever
+ * else it carries, because an object with options is still machine-written data.
+ *
+ * @param {AnswerField} field - The field.
+ * @returns {AnswerKind} The field's answer kind.
+ * @example
+ * kindOf({ key: 'quote', type: 'object', multiple: false }) // 'system'
+ */
+export declare function kindOf(field: AnswerField): AnswerKind;
+/**
+ * Renders an answer for display. An object value is summarised rather than dumped; the panel
+ * offers Copy for the reviewer who wants the payload.
+ *
+ * @param {unknown} value - The held answer.
+ * @param {AnswerField} field - The field it answers.
+ * @returns {string | null} The answer in words, or `null` when nothing has been answered.
+ * @example
+ * renderAnswer(['electricity', 'gas'], services) // 'Electricity, Gas'
+ */
+export declare function renderAnswer(value: unknown, field: AnswerField): string | null;
+/**
+ * Everything a row needs about one answer, in one pass.
+ *
+ * @param {unknown} value - The held answer.
+ * @param {AnswerField} field - The field it answers.
+ * @returns {AnswerView} The row's view of the answer.
+ * @example
+ * describeAnswer('moving', purpose).display // 'Moving home'
+ */
+export declare function describeAnswer(value: unknown, field: AnswerField): AnswerView;
+/** The slice of a step this module reads. */
+export interface AskedStep {
+    id: string;
+    fieldKeys: readonly string[];
+}
+/** The slice of a flow node this module reads. Only step nodes carry a `stepId`. */
+export interface AskedNode {
+    type: string;
+    stepId?: string;
+}
+/**
+ * Every field a customer can actually be asked: one placed on a screen that some journey's flow
+ * reaches. A workspace registers more fields than it asks; code commits the rest, and those sit
+ * on no screen or only on a step no flow references, so placement on a FLOW step is what
+ * separates them.
+ *
+ * Some keys ride a screen only so code can read or commit them there, with no input rendering
+ * them. The host names those in `codeOwned`, and they are left out too.
+ *
+ * @param {readonly AskedStep[]} steps - Every registered step.
+ * @param {readonly (readonly AskedNode[])[]} flows - Each journey's flow nodes.
+ * @param {ReadonlySet<string>} [codeOwned] - Keys a screen carries only for its code.
+ * @returns {Set<string>} The keys of every field a journey asks.
+ * @example
+ * askedFieldKeys(client.steps.listStore.getState(), flows, new Set(['quote_response']))
+ */
+export declare function askedFieldKeys(steps: readonly AskedStep[], flows: readonly (readonly AskedNode[])[], codeOwned?: ReadonlySet<string>): Set<string>;
+/**
+ * The raw payload behind a `system` answer, for the Copy button.
+ *
+ * @param {unknown} value - The held answer.
+ * @returns {string} Pretty-printed JSON, or an empty string for an absent value.
+ * @example
+ * systemPayload({ plans: [] })
+ */
+export declare function systemPayload(value: unknown): string;

package/dist/plugins/devtools/derive/answer-display/answer-display.js

@@ -0,0 +1 @@
+import{deslug as e}from"../plain-language/plain-language.js";var t=`Not answered yet`,n=`Answered on its screen`;function r(t){let n=t.name?.trim();return n!==void 0&&n.length>0?n:e(t.key)}function i(e){let t=e.label?.trim();return t!==void 0&&t.length>0?t:r(e)}function a(e){return e.type===`object`?`system`:e.options!==null&&e.options!==void 0&&e.options.length>0?`options`:e.type===`boolean`?`boolean`:e.type===`number`?`number`:`text`}function o(e,n){let r=n.options?.find(t=>t.value===e);return r===void 0?e===!0?`Yes`:e===!1?`No`:e===null?t:typeof e==`string`?e:typeof e==`number`?String(e):JSON.stringify(e):r.label}function s(e,t){return e==null||e===``?null:Array.isArray(e)?e.length===0?null:e.map(e=>o(e,t)).join(`, `):a(t)===`system`?n:o(e,t)}function c(e,t){let n=a(t),o=s(e,t);return{title:i(t),noun:r(t),kind:n,display:o,answered:o!==null,editable:n!==`system`}}function l(e,t,n=new Set){let r=new Set;for(let e of t)for(let t of e)t.type===`step`&&t.stepId!==void 0&&r.add(t.stepId);let i=new Set;for(let t of e)if(r.has(t.id))for(let e of t.fieldKeys)n.has(e)||i.add(e);return i}function u(e){return e===void 0?``:JSON.stringify(e,null,2)}export{l as askedFieldKeys,c as describeAnswer,a as kindOf,r as nounOf,i as questionOf,s as renderAnswer,u as systemPayload};

package/dist/plugins/devtools/derive/answer-display/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for how an answer is shown to a reviewer and whether it is editable. */
+export { askedFieldKeys, describeAnswer, kindOf, nounOf, questionOf, renderAnswer, systemPayload, } from './answer-display';
+export type { AnswerField, AnswerKind, AnswerView, AskedNode, AskedStep } from './answer-display';

package/dist/plugins/devtools/derive/answer-display/index.js

@@ -0,0 +1 @@
+export{askedFieldKeys,describeAnswer,kindOf,nounOf,questionOf,renderAnswer,systemPayload}from"./answer-display.js";

package/dist/plugins/devtools/derive/answer-history/answer-history.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @file What the visitor answered, screen by screen, in the order they answered it, as a REDUCER
+ * over the SDK's event bus.
+ *
+ * `responses` says what is held NOW, and code commits much of it. So the history is built from
+ * submits instead: on every `step_submit` it records the screen and the values of the fields that
+ * screen asks. The bus fires it after the form commits and BEFORE a following action runs, so an
+ * action's output never lands in a row.
+ *
+ * A screen submitted twice (the visitor went Back and changed an answer) is two entries: the
+ * second entry is what changed. Session state only, never persisted. Immutable: an event that
+ * records nothing answers the SAME array.
+ */
+/** The event shapes this reducer reads, narrowed from the client's `PayloadMap`. */
+export interface HistoryEvent {
+    type: string;
+    step?: {
+        key?: string;
+        name?: string;
+        fieldKeys?: readonly string[];
+    };
+    experience?: {
+        experienceKey?: string;
+        experienceName?: string;
+    };
+}
+/** One answer as it was at its screen's submit. */
+export interface HistoryAnswer {
+    key: string;
+    /** The value as it was when the screen was submitted, never re-read later. */
+    value: unknown;
+}
+/** One submitted screen and the answers it gave. */
+export interface HistoryEntry {
+    /** Unique within the session, for keyed lists. */
+    id: number;
+    experienceKey: string;
+    experienceName: string;
+    stepKey: string;
+    stepName: string;
+    answers: readonly HistoryAnswer[];
+}
+/**
+ * Whether a value is empty in any shape a field can hold nothing in.
+ *
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} `true` for `undefined`, `null`, `''` and `[]`.
+ * @example
+ * isBlank([]) // true
+ */
+export declare function isBlank(value: unknown): boolean;
+/**
+ * The answers a submitted screen gave: the values of the fields it asks, minus the code-owned
+ * ones and the blank ones. Each value is a copy, because an object answer is mutable and a row
+ * must keep what was submitted even if a later screen rewrites it.
+ *
+ * @param {readonly string[]} fieldKeys - The keys the screen asks.
+ * @param {Readonly<Record<string, unknown>>} responses - The responses held at the submit.
+ * @param {ReadonlySet<string>} [codeOwned] - Keys a screen carries only for its code.
+ * @returns {HistoryAnswer[]} The screen's answers, in field order.
+ * @example
+ * submittedAnswers(['postcode'], { postcode: '3000' }) // [{ key: 'postcode', value: '3000' }]
+ */
+export declare function submittedAnswers(fieldKeys: readonly string[], responses: Readonly<Record<string, unknown>>, codeOwned?: ReadonlySet<string>): HistoryAnswer[];
+/**
+ * The history after one event, given the responses held at that moment.
+ *
+ * @param {readonly HistoryEntry[]} history - The history so far.
+ * @param {Readonly<Record<string, unknown>>} responses - The responses held at the event.
+ * @param {HistoryEvent} event - The bus event.
+ * @param {ReadonlySet<string>} [codeOwned] - Keys a screen carries only for its code.
+ * @returns {readonly HistoryEntry[]} The next history, or the same reference when nothing is recorded.
+ * @example
+ * historyStore.on(bus, (history, event) => nextHistory(history, responses, event))
+ */
+export declare function nextHistory(history: readonly HistoryEntry[], responses: Readonly<Record<string, unknown>>, event: HistoryEvent, codeOwned?: ReadonlySet<string>): readonly HistoryEntry[];

package/dist/plugins/devtools/derive/answer-history/answer-history.js

@@ -0,0 +1 @@
+function e(e){return e==null||e===``||Array.isArray(e)&&e.length===0}function t(t,n,r=new Set){return t.filter(t=>!r.has(t)&&!e(n[t])).map(e=>({key:e,value:structuredClone(n[e])}))}function n(e,n,r,i=new Set){if(r.type!==`step_submit`)return e;let a=r.experience?.experienceKey,o=r.step?.key;if(a===void 0||o===void 0||o.length===0)return e;let s=t(r.step?.fieldKeys??[],n,i);if(s.length===0)return e;let c={id:(e.at(-1)?.id??0)+1,experienceKey:a,experienceName:r.experience?.experienceName??a,stepKey:o,stepName:r.step?.name??o,answers:s};return[...e,c].slice(-300)}export{e as isBlank,n as nextHistory,t as submittedAnswers};

package/dist/plugins/devtools/derive/answer-history/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the screen-by-screen answer history reducer. */
+export { isBlank, nextHistory, submittedAnswers } from './answer-history';
+export type { HistoryAnswer, HistoryEntry, HistoryEvent } from './answer-history';

package/dist/plugins/devtools/derive/answer-history/index.js

@@ -0,0 +1 @@
+export{isBlank,nextHistory,submittedAnswers}from"./answer-history.js";

package/dist/plugins/devtools/derive/guide-sections/guide-sections.d.ts

@@ -0,0 +1,67 @@
+/** One section of the guide: a task, its steps, and the tab it is about. */
+export interface GuideSection {
+    id: string;
+    title: string;
+    /** Numbered steps, in order. `**text**` marks a control's label; see {@link emphasis}. */
+    steps: readonly string[];
+    /** Short lines after the steps. */
+    notes: readonly string[];
+    /**
+     * The sidebar tab this section is about, offered as an "Open …" button: a review tab id or a
+     * custom tool's id. Null for a section about no tab.
+     */
+    tab: string | null;
+}
+/** A common problem and what to do about it. */
+export interface GuideFix {
+    problem: string;
+    fix: string;
+}
+/** Which optional tabs this build shows. The guide covers exactly those. */
+export interface GuideAvailability {
+    variations: boolean;
+}
+/** The host's own sections, placed around the SDK's. */
+export interface GuideExtras {
+    /** Sections read before the SDK's tabs, such as how to report an issue. */
+    lead?: readonly GuideSection[];
+    /** Sections read after the SDK's tabs, one per custom tool. */
+    tools?: readonly GuideSection[];
+}
+/**
+ * The guide's sections, in reading order: the host's lead sections, the SDK's sections for the
+ * tabs this build shows, then the host's tool sections.
+ *
+ * @param {GuideAvailability} available - Which optional tabs this build shows.
+ * @param {GuideExtras} [extra] - The host's own sections.
+ * @returns {GuideSection[]} The sections to render.
+ * @example
+ * guideSections({ variations: true }, { tools: [{ id: 'cart', title: 'Inspect the cart', steps: [], notes: [], tab: 'cart' }] })
+ */
+export declare function guideSections(available: GuideAvailability, extra?: GuideExtras): GuideSection[];
+/**
+ * Common problems and what to do, minus any fix that points at a tab this build lacks, followed
+ * by the host's own.
+ *
+ * @param {GuideAvailability} available - Which optional tabs this build shows.
+ * @param {readonly GuideFix[]} [extra] - The host's own fixes.
+ * @returns {GuideFix[]} The fixes to render.
+ * @example
+ * guideFixes({ variations: true }, [{ problem: 'The report did not send', fix: 'Try again.' }])
+ */
+export declare function guideFixes(available: GuideAvailability, extra?: readonly GuideFix[]): GuideFix[];
+/** One run of a guide line: plain or bold. */
+export interface TextRun {
+    text: string;
+    bold: boolean;
+}
+/**
+ * Splits `**label**` markers into runs, so a control's name renders bold without raw HTML. An
+ * unclosed marker stays literal rather than bolding the rest of the line.
+ *
+ * @param {string} line - A guide line.
+ * @returns {TextRun[]} The line's runs, in order.
+ * @example
+ * emphasis('Click **Save**.') // [{ text: 'Click ', bold: false }, { text: 'Save', bold: true }, { text: '.', bold: false }]
+ */
+export declare function emphasis(line: string): TextRun[];

package/dist/plugins/devtools/derive/guide-sections/guide-sections.js

@@ -0,0 +1 @@
+var e=[{id:`session`,title:`See where you are`,steps:[],notes:[`To see the screen you are on and every answer so far, open **This session**.`],tab:`session`},{id:`answers`,title:`Change an answer`,steps:[`Open **Answers**.`,`Find the question. Use **Answered**, **Not answered** or **All** to narrow the list.`,`Click **Change**, or **Answer** if it has none yet.`,`Pick or type the new answer, then click **Save**.`],notes:[`To remove one answer, click **Clear** beside it.`,`To start the whole journey again, click **Start over**, then **Clear everything**.`,`If a question says **Change it on its screen**, go back to that screen and change it there.`],tab:`answers`},{id:`journey`,title:`Go back to an earlier screen`,steps:[`Open **Journey map**.`,`Find a screen on your route. Your route is blue, and your screen says **You are here**.`,`Click the screen, then click **Go back to this screen**.`],notes:[`You can only go back to screens you have already visited.`,`To change how the map looks, pick **Map**, **Timeline** or **Outline** at the top.`],tab:`journey`},{id:`variations`,title:`View a test version of a page`,steps:[`Open **Variations**.`,`Find the test and pick the version you want.`,`Click **Show me this version**. The page reloads showing it.`,`To share exactly what you saw, click **Copy link** and send it.`],notes:[`To go back to normal for that test, click **Leave this one alone**.`],tab:`variations`}],t=[{tab:`journey`,entry:{problem:`I can't click a screen on the Journey map`,fix:`Go back only to screens you have visited.`}}];function n(e,t){return e!==`variations`||t.variations}function r(t,r){return[...r?.lead??[],...e.filter(e=>n(e.tab,t)),...r?.tools??[]]}function i(e,r){return[...t.filter(t=>n(t.tab,e)).map(e=>e.entry),...r??[]]}function a(e){let t=e.split(`**`);return t.length%2==0?[{text:e,bold:!1}]:t.map((e,t)=>({text:e,bold:t%2==1})).filter(e=>e.text.length>0)}export{a as emphasis,i as guideFixes,r as guideSections};

package/dist/plugins/devtools/derive/guide-sections/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the How to use tab's content. */
+export { emphasis, guideFixes, guideSections } from './guide-sections';
+export type { GuideAvailability, GuideExtras, GuideFix, GuideSection, TextRun, } from './guide-sections';

package/dist/plugins/devtools/derive/guide-sections/index.js

@@ -0,0 +1 @@
+export{emphasis,guideFixes,guideSections}from"./guide-sections.js";

package/dist/plugins/devtools/derive/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Public entrypoint for the review tools' pure derivations. Every panel stays thin by pushing
+ * its thinking here, where it is tested off plain objects with no client, no DOM and no store.
+ */
+export { askedFieldKeys, describeAnswer, kindOf, nounOf, questionOf, renderAnswer, systemPayload, } from './answer-display';
+export type { AnswerField, AnswerKind, AnswerView, AskedNode, AskedStep } from './answer-display';
+export { isBlank, nextHistory, submittedAnswers } from './answer-history';
+export type { HistoryAnswer, HistoryEntry, HistoryEvent } from './answer-history';
+export { emphasis, guideFixes, guideSections } from './guide-sections';
+export type { GuideAvailability, GuideExtras, GuideFix, GuideSection, TextRun, } from './guide-sections';
+export { buildOutline } from './journey-outline';
+export type { OutlineCondition, OutlineEdge, OutlineInput, OutlineNode, OutlineRow, ScreenState, } from './journey-outline';
+export { nextOpenOrder, pickJourney } from './journey-pick';
+export type { InstanceLike, JourneyPickOptions, OpenOrderEvent } from './journey-pick';
+export { COLOURS, LANE_WIDTH, ROW_HEIGHT, buildTimeline } from './journey-timeline';
+export type { TimelineEdge, TimelineLayout, TimelineNext, TimelineNode } from './journey-timeline';
+export { BREADTH, DEPTH, buildTree } from './journey-tree';
+export type { FlowEnd, TreeInput, TreeJump, TreeLayout, TreeLink, TreeNode, TreeNodeKind, } from './journey-tree';
+export { DEVELOPER_LABEL, NODE_LABELS, TAB_INTROS, TAB_LABELS, configSourceLabel, deslug, screenName, } from './plain-language';
+export type { ReviewTabId } from './plain-language';
+export { UNDESCRIBABLE, describeRule, varKeyOf } from './plain-logic';
+export type { FieldLookup, FieldSummary } from './plain-logic';
+export { derivePosture } from './safety-posture';
+export type { PostureOptions, SafetyPosture } from './safety-posture';
+export { nextTrails } from './visited-steps';
+export type { Trails, VisitedEvent } from './visited-steps';
+export { nextRoute } from './walk-route';
+export type { RouteEntry } from './walk-route';

package/dist/plugins/devtools/derive/index.js

@@ -0,0 +1 @@
+import{DEVELOPER_LABEL as e,NODE_LABELS as t,TAB_INTROS as n,TAB_LABELS as r,configSourceLabel as i,deslug as a,screenName as o}from"./plain-language/plain-language.js";import{askedFieldKeys as s,describeAnswer as c,kindOf as l,nounOf as u,questionOf as d,renderAnswer as f,systemPayload as p}from"./answer-display/answer-display.js";import{isBlank as m,nextHistory as h,submittedAnswers as g}from"./answer-history/answer-history.js";import{emphasis as _,guideFixes as v,guideSections as y}from"./guide-sections/guide-sections.js";import{UNDESCRIBABLE as b,describeRule as x,varKeyOf as S}from"./plain-logic/plain-logic.js";import{buildOutline as C}from"./journey-outline/journey-outline.js";import{nextOpenOrder as w,pickJourney as T}from"./journey-pick/journey-pick.js";import{BREADTH as E,DEPTH as D,buildTree as O}from"./journey-tree/journey-tree.js";import"./journey-tree/index.js";import{COLOURS as k,LANE_WIDTH as A,ROW_HEIGHT as j,buildTimeline as M}from"./journey-timeline/journey-timeline.js";import"./journey-timeline/index.js";import{derivePosture as N}from"./safety-posture/safety-posture.js";import{nextTrails as P}from"./visited-steps/visited-steps.js";import{nextRoute as F}from"./walk-route/walk-route.js";export{E as BREADTH,k as COLOURS,D as DEPTH,e as DEVELOPER_LABEL,A as LANE_WIDTH,t as NODE_LABELS,j as ROW_HEIGHT,n as TAB_INTROS,r as TAB_LABELS,b as UNDESCRIBABLE,s as askedFieldKeys,C as buildOutline,M as buildTimeline,O as buildTree,i as configSourceLabel,N as derivePosture,c as describeAnswer,x as describeRule,a as deslug,_ as emphasis,v as guideFixes,y as guideSections,m as isBlank,l as kindOf,h as nextHistory,w as nextOpenOrder,F as nextRoute,P as nextTrails,u as nounOf,T as pickJourney,d as questionOf,f as renderAnswer,o as screenName,g as submittedAnswers,p as systemPayload,S as varKeyOf};

package/dist/plugins/devtools/derive/journey-outline/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the flow graph to indented outline fold. */
+export { buildOutline } from './journey-outline';
+export type { OutlineCondition, OutlineEdge, OutlineInput, OutlineNode, OutlineRow, ScreenState, } from './journey-outline';

package/dist/plugins/devtools/derive/journey-outline/index.js

@@ -0,0 +1 @@
+export{buildOutline}from"./journey-outline.js";

package/dist/plugins/devtools/derive/journey-outline/journey-outline.d.ts

@@ -0,0 +1,86 @@
+import type { FieldLookup } from '../plain-logic';
+/** The slice of a `treeStore` node this module reads, narrowed so tests can build plain fixtures. */
+export interface OutlineNode {
+    id: string;
+    type: string;
+    name?: string;
+    stepKey?: string;
+    conditionId?: string;
+    actionKey?: string;
+    experienceKey?: string;
+}
+/** The slice of a `treeStore` edge this module reads. */
+export interface OutlineEdge {
+    id: string;
+    sourceNodeId: string;
+    destinationNodeId: string;
+    sourceHandle?: string;
+}
+/** The slice of a registered condition this module reads. */
+export interface OutlineCondition {
+    id: string;
+    name: string;
+    logic: unknown;
+}
+/** Where a screen sits relative to the visitor. */
+export type ScreenState = 'visited' | 'current' | 'ahead';
+/** One row of the outline. */
+export type OutlineRow = {
+    kind: 'start';
+    id: string;
+    depth: number;
+    label: string;
+} | {
+    kind: 'screen';
+    id: string;
+    depth: number;
+    label: string;
+    stepKey: string | null;
+    state: ScreenState;
+} | {
+    kind: 'decision';
+    id: string;
+    depth: number;
+    label: string;
+    rule: string;
+} | {
+    kind: 'arm';
+    id: string;
+    depth: number;
+    label: string;
+} | {
+    kind: 'end';
+    id: string;
+    depth: number;
+    label: string;
+} | {
+    kind: 'journey';
+    id: string;
+    depth: number;
+    label: string;
+} | {
+    kind: 'backref';
+    id: string;
+    depth: number;
+    label: string;
+};
+/** Everything {@link buildOutline} reads. */
+export interface OutlineInput {
+    nodes: readonly OutlineNode[];
+    edges: readonly OutlineEdge[];
+    conditions: readonly OutlineCondition[];
+    fieldLookup: FieldLookup;
+    /** Step keys the visitor has entered this session. */
+    visited: ReadonlySet<string>;
+    /** The step the visitor is on right now. */
+    currentStepKey: string | null;
+}
+/**
+ * Folds the graph into rows. Pure: everything it needs arrives as an argument.
+ *
+ * @param {OutlineInput} input - The flow, its conditions, the field index and the visitor's trail.
+ * @returns {OutlineRow[]} The outline's rows, in reading order.
+ * @example
+ * buildOutline({ nodes, edges, conditions, fieldLookup, visited, currentStepKey: 'postcode' })
+ */
+export declare function buildOutline({ nodes, edges, conditions, fieldLookup, visited, currentStepKey, }: OutlineInput): OutlineRow[];

package/dist/plugins/devtools/derive/journey-outline/journey-outline.js

@@ -0,0 +1 @@
+import{NODE_LABELS as e,deslug as t,screenName as n}from"../plain-language/plain-language.js";import{describeRule as r}from"../plain-logic/plain-logic.js";var i=[{handle:`true`,label:`Yes`},{handle:`false`,label:`Otherwise`}],a=400,o=24,s=new Set([`origin`,`step`,`condition`,`experience`]);function c(e,t,n){return e!==null&&e===n?`current`:e!==null&&t.has(e)?`visited`:`ahead`}function l({nodes:l,edges:u,conditions:d,fieldLookup:f,visited:p,currentStepKey:m}){let h=new Map(l.map(e=>[e.id,e])),g=new Map(d.map(e=>[e.id,e])),_=new Map;for(let e of u){let t=_.get(e.sourceNodeId);t===void 0?_.set(e.sourceNodeId,[e]):t.push(e)}let v=[],y=new Map,b=(e,t)=>(_.get(e)??[]).find(e=>e.sourceHandle===t),x=e=>{let t=_.get(e)??[];return t.find(e=>e.sourceHandle===`true`)??t.find(e=>e.sourceHandle===void 0)??t[0]},S=e=>!s.has(e.type),C=(r,i)=>{if(r.type===`origin`)return{row:{kind:`start`,id:r.id,depth:i,label:e.origin},backref:e.origin};if(r.type===`step`){let e=n(r.name,r.stepKey);return{row:{kind:`screen`,id:r.id,depth:i,label:e,stepKey:r.stepKey??null,state:c(r.stepKey??null,p,m)},backref:e}}if(r.type===`experience`){let e=r.experienceKey??`another journey`;return{row:{kind:`journey`,id:r.id,depth:i,label:t(e)},backref:`opening ${e}`}}let a=t(r.actionKey??r.name??r.type);return{row:{kind:`end`,id:r.id,depth:i,label:a},backref:a}},w=e=>{let t=new Set,n=e;for(;!t.has(n);){let e=h.get(n);if(e===void 0||!S(e))return{next:n};t.add(n);let r=x(n);if(r===void 0)return{end:e};n=r.destinationNodeId}return null},T=(e,t)=>{let n=e.conditionId===void 0?void 0:g.get(e.conditionId),a=r(n?.logic,f);y.set(e.id,`the “${a}” decision`),v.push({kind:`decision`,id:e.id,depth:t,label:a,rule:JSON.stringify(n?.logic??null,null,2)});for(let n of i){let r=b(e.id,n.handle);r!==void 0&&(v.push({kind:`arm`,id:`${e.id}:${n.handle}`,depth:t+1,label:n.label}),E(r.destinationNodeId,t+2))}},E=(e,t)=>{if(e===void 0||v.length>=a||t>o)return;let n=w(e);if(n===null)return;if(`end`in n){let e=C(n.end,t).row.label;v.push({kind:`end`,id:`${n.end.id}:end:${v.length}`,depth:t,label:e});return}let r=n.next,i=h.get(r);if(i===void 0)return;let s=y.get(r);if(s!==void 0){v.push({kind:`backref`,id:`${r}:back:${v.length}`,depth:t,label:s});return}if(i.type===`condition`){T(i,t);return}let{row:c,backref:l}=C(i,t);y.set(r,l),v.push(c),E(x(r)?.destinationNodeId,t)};if(E(l.find(e=>e.type===`origin`)?.id,0),v.length===0)for(let e of l)e.type===`step`&&v.push(C(e,0).row);return v}export{l as buildOutline};

package/dist/plugins/devtools/derive/journey-pick/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for picking the open experience instance in front. */
+export { nextOpenOrder, pickJourney } from './journey-pick';
+export type { InstanceLike, JourneyPickOptions, OpenOrderEvent } from './journey-pick';

package/dist/plugins/devtools/derive/journey-pick/index.js

@@ -0,0 +1 @@
+export{nextOpenOrder,pickJourney}from"./journey-pick.js";

package/dist/plugins/devtools/derive/journey-pick/journey-pick.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file Which open experience instance the reviewer is looking at.
+ *
+ * Several instances can be open at once (an inline entry widget under a full-screen overlay, a
+ * modal over both). The host knows its own stacking, so it names the experiences that sit on top
+ * in `precedence`, topmost first. Without a match there, the instance opened most recently wins,
+ * which is the one a new overlay puts in front. The record of what opened when is kept from the
+ * event bus by {@link nextOpenOrder}.
+ */
+/** The slice of an `ExperienceInstance` the pick reads, narrow so tests can build fakes. */
+export interface InstanceLike {
+    id: string;
+    experienceKey: string;
+    experienceName: string;
+    isOpenStore: {
+        getState: () => boolean;
+    };
+    currentStepStore: {
+        getState: () => {
+            key: string;
+            name?: string;
+        } | null;
+    };
+    currentNodeStore: {
+        getState: () => {
+            type: string;
+        } | null;
+    };
+}
+/** The host's say on which instance is in front. */
+export interface JourneyPickOptions {
+    /** Experience keys never picked: the devtools themselves, and any the host hides. */
+    exclude: ReadonlySet<string>;
+    /** Experience keys, topmost first. */
+    precedence: readonly string[];
+    /** Instance ids in the order they opened, oldest first. */
+    openOrder: readonly string[];
+}
+/** The bus event shapes {@link nextOpenOrder} reads, narrowed from the client's `PayloadMap`. */
+export interface OpenOrderEvent {
+    type: string;
+    experience?: {
+        id?: string;
+    };
+}
+/**
+ * The open instance the reviewer is looking at. Among the open instances whose experience is not
+ * excluded: the first match by `precedence`, else the one that appears latest in `openOrder`, else
+ * the last one in list order.
+ *
+ * @template {InstanceLike} T - The caller's instance type, handed back whole.
+ * @param {readonly T[]} instances - Every experience instance.
+ * @param {JourneyPickOptions} options - Exclusions, precedence and the order instances opened in.
+ * @returns {T | undefined} The instance in front, or `undefined` when none is open.
+ * @example
+ * pickJourney(client.experienceInstances.listStore.getState(), {
+ *   exclude: new Set(['devtools']),
+ *   precedence: ['checkout-modal'],
+ *   openOrder,
+ * })
+ */
+export declare function pickJourney<T extends InstanceLike>(instances: readonly T[], options: JourneyPickOptions): T | undefined;
+/**
+ * The open order after one bus event. `experience_open` moves the instance's id to the end (an
+ * id appears once), and `experience_close` removes it.
+ *
+ * @param {readonly string[]} order - Instance ids in the order they opened, oldest first.
+ * @param {OpenOrderEvent} event - The bus event.
+ * @returns {readonly string[]} The next order, or the same reference when the event changes nothing.
+ * @example
+ * createStore<readonly string[]>([]).on(client.eventBus, nextOpenOrder)
+ */
+export declare function nextOpenOrder(order: readonly string[], event: OpenOrderEvent): readonly string[];

package/dist/plugins/devtools/derive/journey-pick/journey-pick.js

@@ -0,0 +1 @@
+function e(e,t){let n=e.filter(e=>!t.exclude.has(e.experienceKey)&&e.isOpenStore.getState());for(let e of t.precedence){let t=n.find(t=>t.experienceKey===e);if(t!==void 0)return t}let r,i=-1;for(let e of n){let n=t.openOrder.lastIndexOf(e.id);n>i&&(r=e,i=n)}return r??n.at(-1)}function t(e,t){let n=t.experience?.id;return n===void 0||n.length===0?e:t.type===`experience_open`?e.at(-1)===n?e:[...e.filter(e=>e!==n),n]:t.type===`experience_close`&&e.includes(n)?e.filter(e=>e!==n):e}export{t as nextOpenOrder,e as pickJourney};

package/dist/plugins/devtools/derive/journey-timeline/index.d.ts

@@ -0,0 +1,3 @@
+/** @file Public entrypoint for the flow graph to git-style timeline. */
+export { COLOURS, LANE_WIDTH, ROW_HEIGHT, buildTimeline } from './journey-timeline';
+export type { TimelineEdge, TimelineLayout, TimelineNext, TimelineNode } from './journey-timeline';

package/dist/plugins/devtools/derive/journey-timeline/index.js

@@ -0,0 +1 @@
+export{COLOURS,LANE_WIDTH,ROW_HEIGHT,buildTimeline}from"./journey-timeline.js";