@intellectif/lk-react 23.0.1 → 23.1.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @intellectif/lk-react
 
+## 23.1.1
+
+### Patch Changes
+
+- [#90](https://github.com/intellectif/learning-kit/pull/90) [`9b5f5ef`](https://github.com/intellectif/learning-kit/commit/9b5f5ef6243f825c1336628d38816789993455b3) Thanks [@diego28e](https://github.com/diego28e)! - **Multiple choice under `feedback: false`**: no longer says "Answer submitted." before the learner has answered.
+
+  **Action required:** none.
+
+  - With `delivery={{ feedback: false }}`, a `<MultipleChoice>` announced "Answer submitted." in its live region as soon as it rendered. It now says nothing until the learner submits, as every other activity component does; after a submit it still says only that the answer was received.
+  - **Built with tsdown**, as tsup is no longer maintained. Every entry point exports the same names in ESM and CommonJS, each module still starts with `'use client'`, and the declarations describe the same API; only the names of the internal chunk files differ.
+  - A new test walks all six activity components through the same moment, in practice and exam mode, under every delivery policy, so a component that drifts from the others fails by name.
+
+## 23.1.0
+
+### Minor Changes
+
+- [#86](https://github.com/intellectif/learning-kit/pull/86) [`2215060`](https://github.com/intellectif/learning-kit/commit/22150600b0d8f5f058214a0551566b58e154276d) Thanks [@diego28e](https://github.com/diego28e)! - **Coaching on a reading aloud**: "Coach me on this reading" under a read-aloud's marks, where a model may coach only the words the speech engine marked.
+
+  **Action required:** none unless your code switches over `AiFeature`, `AiRefusal` or `InteractionKind` without a `default` branch (new members `'pronunciation-coaching'`, `'contradicts-marks'` and `'ai-coaching-shown'`), reads `AiCheckCase.request` without narrowing on `feature`, or implements a complete `LkStrings` (six new keys). Nothing changes until you pass a `pronunciationCoaching` port. Install lk-core 1.1.0 with lk-react 23.1.0: lk-react calls the new lk-core functions, and its peer range moves to `^1.1.0`. See https://github.com/intellectif/learning-kit/blob/main/docs/upgrading.md
+
+  - **lk-core:** `aiCoachingRequest` builds what a model is given: the text, the engine's marks word by word — with each word's sounds and what each was heard as, when the marks come from the assessment — its dimension scores, and the grade. `checkAiCoaching` checks the reply before a learner sees it. Every word it coaches must be one the engine marked mispronounced or omitted, and every sound one the engine reported for that word; anything else refuses the whole reply as `contradicts-marks`. The words come back in reading order, each as the marks show it, and no number in the reply is read. An assessment the grader would not read (no speech, unscripted, another text or locale) gives no coaching.
+  - **lk-react:** a `pronunciationCoaching` port on `LearnerAi`. `<ReadAloud>` offers coaching under its marks in `practice` once a take is graded and in `review` wherever marks are shown, from a kept assessment or a stored grade; never in `exam`. `<PronunciationFeedback>` offers it too, given the item's `id` and `title` in `data`, and takes `ai`, `renderMode`, `delivery` and `onInteraction` for it. It follows the author's and the paper's `ai.explanations` and needs `feedback`, not `solutions`. One coaching per take. `useAiCoaching` gives marks you draw yourself the same rules.
+  - **Records:** `ai-coaching-shown` (how many words were coached, provenance and usage; never the text), and `ai-help-refused` with `feature: 'pronunciation-coaching'`.
+  - **ai-check:** a `pronunciationCoaching` port runs four reading cases: a mispronounced "th" and a word left out, a clean reading, the same slips from a stored grade without sounds, and coaching asked for in Spanish.
+  - Six new strings: `aiCoaching`, `aiCoachingLoading`, `aiCoachingHeading`, `aiCoachingUnavailable`, `aiCoachingWords`, `aiCoachingSound`.
+  - **Stability:** the promise now says what a minor may add to a type the SDK hands you — a union member, a `LkStrings` key, an optional property — and that a `default` branch keeps a switch correct across minors.
+
 ## 23.0.1
 
 ### Patch Changes

package/README.md

@@ -75,7 +75,7 @@ export function Demo() {
 - **`<InteractiveVideo>`** — a video that stops at each quiz and asks its questions over itself, then plays on. **A formative tool**, for lessons and practice — deliver official summative exams with `<ActivitySequence>`. One player: a progress bar that marks every quiz and previews the caption under the pointer, speed, volume, captions drawn from WebVTT it parses itself (through a `captionsLoader` when the file needs the learner's credentials) — in one language or two at once, a second line under the first for a learner matching what they hear to what it means — a contents and transcript panel, picture-in-picture, fullscreen and a keyboard map with a shortcut sheet. A quiz covers the video and grows the player rather than scrolling inside it, every question of an opened quiz stays mounted so a rewind loses no answer, the controls are `inert` while it is open, and a **required** quiz holds both playback and seeking until it is answered. Answers report with the slot the question sits in and the quiz it belongs to, and `onProgress` gives a resume point that is never past an unanswered required quiz. A host with renderers of its own draws any question itself through `renderQuestion` — the video still counts it, tells it when it leaves the screen so it can stop its microphone, and holds Finish while its answer is still on its way. See the [interactive video guide](https://github.com/intellectif/learning-kit/blob/main/docs/interactive-video.md).
 - **Delivery policies** — `delivery` on any activity, `<ActivitySequence>` or `<InteractiveVideo>` switches off feedback, solutions, hints or AI help for that paper, so one question serves practice and a final without being authored twice. It can only take away, an empty policy is exactly the default, and a pager's policy holds in every question it holds — a host's own renderer included. See [Delivery policies](https://github.com/intellectif/learning-kit/blob/main/docs/delivery.md).
 - **Scoring policies** — `scoring` on any activity, `<ActivitySequence>` or `<InteractiveVideo>` gives a practice question "Try again", chooses which try counts, and charges for tries and hints, saying what a hint costs before the learner asks. The right answer and "Explain my answer" wait until the tries end, a set waits for a question being tried again, and no policy changes nothing. See [Scoring policies](https://github.com/intellectif/learning-kit/blob/main/docs/scoring.md).
-- **AI help for learners** — "Explain my answer" after grading and "Get a hint" before submit, in `<MultipleChoice>`, `<FillInTheBlanks>`, `<GapSelect>` and `<Dictation>` (explanations only), and "Get feedback on my draft" in `<WrittenResponse>` in practice — revise and ask again, and a correction that quotes words the learner never wrote refuses the feedback — through ports **you** supply with `<LkAiProvider>` or an `ai` prop (also on `<ActivitySequence>` and `<InteractiveVideo>`). The SDK never calls a model or holds a key: it builds the facts your model is given, refuses an explanation that contradicts the grade and a hint that contains the answer, marks everything a model wrote, and drops a late answer. Never in `exam`. What was shown reaches `onInteraction` with the model that wrote it and what the call cost; what was refused reaches it with the reason, and never the text. See the [AI guide](https://github.com/intellectif/learning-kit/blob/main/docs/ai.md).
+- **AI help for learners** — "Explain my answer" after grading and "Get a hint" before submit, in `<MultipleChoice>`, `<FillInTheBlanks>`, `<GapSelect>` and `<Dictation>` (explanations only), "Get feedback on my draft" in `<WrittenResponse>` in practice — revise and ask again, and a correction that quotes words the learner never wrote refuses the feedback — and "Coach me on this reading" under the marks of `<ReadAloud>` and `<PronunciationFeedback>`, where coaching on a word the speech engine did not mark is refused, through ports **you** supply with `<LkAiProvider>` or an `ai` prop (also on `<ActivitySequence>` and `<InteractiveVideo>`). The SDK never calls a model or holds a key: it builds the facts your model is given, refuses an explanation that contradicts the grade and a hint that contains the answer, marks everything a model wrote, and drops a late answer. Never in `exam`. What was shown reaches `onInteraction` with the model that wrote it and what the call cost; what was refused reaches it with the reason, and never the text. See the [AI guide](https://github.com/intellectif/learning-kit/blob/main/docs/ai.md).
 - **`<ActivitySequence>`** — in-place "question set" pager (Previous/Next, "Question X of N", no scrolling, focus-managed). Accepts item groups and keeps their stimulus beside every question; `onSubmit` reports every raw answer with its `slotId`, which is the only response channel an `exam` sequence has. `onFinished` is the completion signal for a set that mixes scored and deferred-graded items, where `onComplete` can never fire. A read-aloud slot takes its storage from `recordingBinding`, whose methods are told which slot a take belongs to, and a `review` its per-word marks from `assessments`, keyed by `slotId` — there is a [worked example](https://github.com/intellectif/learning-kit/blob/main/docs/speech-assessment.md#in-a-question-set).
 - **Resume and review a whole attempt** — `<ActivitySequence>` takes `defaultIndex`, `responses` and `submittedSlotIds` (read at mount; remount with a `key` to show a different attempt), so an interrupted paper reopens on the right question with the right answers and already-committed questions still committed. `onIndexChange` reports every position the pager lands on, including a clamp it had to apply. Pass `renderMode="review"` plus server-computed `outcomes` to render a finished attempt read-only. Pairs with `serializeAttemptState` / `restoreAttemptState` in `lk-core`.
 - **`renderMode`** — `practice` (default: the component scores locally and reveals correctness), `exam` (never scores, never reveals; submit emits the raw response for the server to grade), `review` (read-only, marks correctness only from an `outcome` you supply). This is the single switch that takes grading off the client.
@@ -85,7 +85,7 @@ export function Demo() {
 - **`<StimulusPanel>`** — a shared passage / recording / image (an item group's stimulus) as a landmark region; the sequence uses it, and a custom runner can too.
 - **`<ActivityPreview>`** — an editor's preview. Renders a draft in any `renderMode` with a simulated `response` (marked with `evaluate()` in `review`), and a translatable notice — or your `fallback`, handed the issues — while `validateDraft` says the draft is not finished. Nothing it renders is recorded, and a recording's play limit is counted in memory only.
 - **Custom activity types** — `renderers={{ 'my-type': MyRenderer }}` on the sequence; a key matching a built-in overrides it, so you can replace a bundled renderer without forking the sequencer. A renderer is given the same contract the SDK's own components have: a `question` prop that says when it is the question on screen (so it can stop its microphone), holds the set while its own work is in flight, gives it somewhere to portal a popover, and reports what the learner did through calls that keep one identity.
-- **AI help in a question you draw** — `useAiHints`, `useAiExplanation` and `useAiWritingFeedback` give a host's own renderer the rules, the facts and the refusals the bundled components use, without their buttons. `ask` does nothing where the rules say no, so an exam reaches no model however the page asks.
+- **AI help in a question you draw** — `useAiHints`, `useAiExplanation`, `useAiWritingFeedback` and `useAiCoaching` give a host's own renderer the rules, the facts and the refusals the bundled components use, without their buttons. `ask` does nothing where the rules say no, so an exam reaches no model however the page asks.
 - **Rich text, opt-in** — `sanitizeHtml` renders author-supplied `questionHtml` / `promptHtml`. The SDK ships **no** sanitiser and injects no HTML without one; without it the escaped plain-text field is used. (`FillInTheBlanks` ignores `passageHtml` by design — its passage hosts the answer inputs.)
 - **Media per question** — optional `image` / `audio` / `video` / `embed` (YouTube/Vimeo iframe) above the question; alt-text required for `image`/`embed` (WCAG).
 - **Playback policy for listening papers** — an audio recording can declare `maxPlays`, `seek: 'none'` and `rate: 'fixed'`. The SDK then renders its own accessible transport (44px targets, a live plays-remaining status, an exhausted button that stays focusable and says why) and enforces the policy from the element's own events, so a hardware media key goes through the budget too. Wire `mediaBudget` on `<ActivitySequence>` to make a play budget survive a refresh.
@@ -95,7 +95,7 @@ export function Demo() {
 - **`useSpeechRecorder(options)`** — the capture half of a read-aloud, usable on its own: microphone permission, an RMS level for a meter, a minimum take length, and an auto-stop measured from the **sample count** rather than a timer, so a take can never outrun its own limit. It yields **16 kHz mono 16-bit PCM WAV** — the one format `inspectWav` in `lk-core` measures without a decoder. SSR-safe by construction (support is discovered inside `start()`, never probed during render, so a server render and its hydration cannot disagree), and the microphone and the audio context are released on stop, discard, error and unmount alike. Where a Content-Security-Policy's `script-src` does not allow `blob:`, serve `CAPTURE_PROCESSOR_SOURCE` — exported beside the hook, with the contract it meets written on it — and pass its URL as `workletUrl`. A `workletUrl` that fails to load is not reported: the hook falls back to the main-thread `ScriptProcessorNode`, so check that the module is fetched.
 - **`<ThemeProvider>` + `defaults.css`** — `--lk-*` design-token system; automatic dark mode via `prefers-color-scheme` (SSR-safe with `useSyncExternalStore`).
 - **`createTailwindTheme(theme)`** — optional Tailwind interop; consume the SDK palette from your own utilities.
-- **`<LkIntlProvider>`** — all 196 strings the SDK's own chrome renders, replaceable in one place, with a per-component `strings` prop for the exceptions. Interpolation and plurals are **functions**, not format strings, so your `Intl.PluralRules` does the work and TypeScript checks the arity. `locale` sets `lang` and derives `dir`; the skin uses logical properties, so RTL follows. The SDK ships the mechanism and **English only** — see [docs/i18n.md](https://github.com/intellectif/learning-kit/blob/main/docs/i18n.md).
+- **`<LkIntlProvider>`** — all 202 strings the SDK's own chrome renders, replaceable in one place, with a per-component `strings` prop for the exceptions. Interpolation and plurals are **functions**, not format strings, so your `Intl.PluralRules` does the work and TypeScript checks the arity. `locale` sets `lang` and derives `dir`; the skin uses logical properties, so RTL follows. The SDK ships the mechanism and **English only** — see [docs/i18n.md](https://github.com/intellectif/learning-kit/blob/main/docs/i18n.md).
 - **WCAG 2.2 AA** — axe-clean unit + Playwright e2e tests; full keyboard operability; numerically-verified contrast.
 - **RSC-compatible** — every component carries `'use client'` and hydrates inside a React Server Component tree.
 
@@ -119,7 +119,7 @@ export function Demo() {
 | `@intellectif/lk-react/hooks/useSpeechRecorder` | Microphone capture to 16 kHz mono WAV, and `CAPTURE_PROCESSOR_SOURCE` for a self-hosted worklet |
 | `@intellectif/lk-react/hooks/useXAPI` | LRS delivery (retry, never-throws) |
 | `@intellectif/lk-react/ai/LkAiProvider` | `<LkAiProvider>`, `useLearnerAi`, and the `LearnerAi` type |
-| `@intellectif/lk-react/ai/useAiHelp` | `useAiHints`, `useAiExplanation`, `useAiWritingFeedback` — the AI rules without the SDK's own buttons |
+| `@intellectif/lk-react/ai/useAiHelp` | `useAiHints`, `useAiExplanation`, `useAiWritingFeedback`, `useAiCoaching` — the AI rules without the SDK's own buttons |
 | `@intellectif/lk-react/i18n/LkIntlProvider` | `<LkIntlProvider>`, `useLkStrings`, `useLkDirection`, `DEFAULT_STRINGS`, `mergeStrings`, `directionForLocale` |
 | `@intellectif/lk-react/theme/ThemeProvider` | `<ThemeProvider>`, `darkTheme`, `useTheme`, `createTailwindTheme` |
 | `@intellectif/lk-react/theme/defaults.css` | Tokens (required) |
@@ -151,9 +151,13 @@ subpath of their own.
 
 ### Versioning note
 
-`@intellectif/lk-core` is a **peer** dependency, so widening its range is a breaking
-change for installs and forces a `lk-react` major. Some majors here — **5.0.0**
-is the clearest — are exactly that and change no React API. Others do: 6.0.0
+`@intellectif/lk-core` is a **peer** dependency. Before 1.0 every `lk-core` minor
+forced a `lk-react` major, which is why this package is at 23.x; since 1.0 a
+`lk-core` minor or patch releases no `lk-react` at all, and when `lk-react` needs a
+newer `lk-core` its own release says which
+([Stability](https://github.com/intellectif/learning-kit/blob/main/docs/stability.md#the-two-version-numbers)).
+Some of the early majors — **5.0.0** is the clearest — are only that peer bump and
+change no React API. Others do: 6.0.0
 added five `<ActivitySequence>` props, a `restored` arm to `SequenceItemOutcome`
 that an exhaustive `switch` must handle, and a changed reset target for
 `<MultipleChoice>`. Always read the
@@ -165,7 +169,7 @@ before assuming a migration is needed.
 - **What is supported, and since when** — [Features](https://github.com/intellectif/learning-kit/blob/main/docs/features.md): every activity and capability, the `lk-core` / `lk-react` versions it arrived in, and its guide.
 - **What changed** — [GitHub Releases](https://github.com/intellectif/learning-kit/releases), one per package version, and the same notes in each package's `CHANGELOG.md` (it ships in the npm package, so it is in your `node_modules` too). Notes written since release notes gained a template — every release after lk-core 0.20.0 / lk-react 20.0.0 — start with a one-line summary and **Action required**: `none`, or what to do. Earlier notes lead with the detail; the version map in the upgrading guide says what each one asks of you.
 - **How to upgrade** — [Upgrading](https://github.com/intellectif/learning-kit/blob/main/docs/upgrading.md): which `lk-core` goes with which `lk-react`, and a section per release saying what, if anything, you need to change. A `lk-react` major is often only the `lk-core` peer bump; the map says so.
-- **Hearing about a release** — on GitHub, **Watch → Custom → Releases**, or subscribe to [the releases feed](https://github.com/intellectif/learning-kit/releases.atom). Better still, let your dependency bot bring each release to you as a pull request, with its notes — and keep the two packages together in one, since they move together:
+- **Hearing about a release** — on GitHub, **Watch → Custom → Releases**, or subscribe to [the releases feed](https://github.com/intellectif/learning-kit/releases.atom). Better still, let your dependency bot bring each release to you as a pull request, with its notes — and keep the two packages together in one, since a `lk-react` release names the `lk-core` it needs:
 
   ```yaml
   # .github/dependabot.yml — one entry per directory with a package.json
@@ -181,7 +185,7 @@ before assuming a migration is needed.
 
   With Renovate: `"packageRules": [{ "matchPackageNames": ["@intellectif/lk-core", "@intellectif/lk-react"], "groupName": "learning-kit" }]`.
 
-  `lk-core` is still `0.x`, and a caret range on a `0.x` version matches only that minor: `^0.18.0` never installs `0.19.0`. A bot is how you find out there is one.
+  A caret range installs every later minor and patch of its major — `^1.2.0` takes `1.3.0` — and never a new major. A bot is how you hear about either, with its notes.
 
 ## Documentation
 

package/dist/ActivityErrorBoundary-B379hvtL.cjs

@@ -0,0 +1,39 @@
+'use client';
+const require_useAiHelp = require("./useAiHelp-h9yOLFqt.cjs");
+const require_LkIntlProvider = require("./LkIntlProvider-oi57lYB0.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/components/ActivityErrorBoundary.tsx
+/**
+* Catches render errors in an activity subtree. In development it renders the
+* full error stack to aid debugging; in production it renders an accessible,
+* generic fallback (optionally naming the activity) so a single broken
+* activity never crashes the host application.
+*/
+var ActivityErrorBoundary = class extends react.Component {
+	state = { error: null };
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	render() {
+		const { error } = this.state;
+		if (!error) return this.props.children;
+		if (require_useAiHelp.isDevelopment()) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			role: "alert",
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: (this.props.strings ?? require_LkIntlProvider.DEFAULT_STRINGS).activityFailed }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", { children: error.stack ?? error.message })]
+		});
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			role: "alert",
+			children: this.props.activityTitle ? (this.props.strings ?? require_LkIntlProvider.DEFAULT_STRINGS).activityFailedNamed(this.props.activityTitle) : (this.props.strings ?? require_LkIntlProvider.DEFAULT_STRINGS).activityFailedUnnamed
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "ActivityErrorBoundary", {
+	enumerable: true,
+	get: function() {
+		return ActivityErrorBoundary;
+	}
+});
+
+//# sourceMappingURL=ActivityErrorBoundary-B379hvtL.cjs.map

package/dist/ActivityErrorBoundary-B379hvtL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityErrorBoundary-B379hvtL.cjs","names":["Component","isDevelopment","DEFAULT_STRINGS"],"sources":["../src/components/ActivityErrorBoundary.tsx"],"sourcesContent":["'use client';\n\nimport { Component, type ReactNode } from 'react';\nimport type { LkStrings } from '../i18n/strings.js';\nimport { DEFAULT_STRINGS } from '../i18n/strings.js';\nimport { isDevelopment } from './_internal.js';\n\nexport interface ActivityErrorBoundaryProps {\n  /** Shown in the production fallback when a render error occurs. */\n  activityTitle?: string;\n  /**\n   * Chrome text. A class component cannot call `useLkStrings`, so the public\n   * wrapper reads the hook and hands the resolved dictionary down.\n   */\n  strings?: LkStrings;\n  children: ReactNode;\n}\n\ninterface ActivityErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Catches render errors in an activity subtree. In development it renders the\n * full error stack to aid debugging; in production it renders an accessible,\n * generic fallback (optionally naming the activity) so a single broken\n * activity never crashes the host application.\n */\nexport class ActivityErrorBoundary extends Component<\n  ActivityErrorBoundaryProps,\n  ActivityErrorBoundaryState\n> {\n  state: ActivityErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): ActivityErrorBoundaryState {\n    return { error };\n  }\n\n  render(): ReactNode {\n    const { error } = this.state;\n    if (!error) {\n      return this.props.children;\n    }\n\n    // The same answer every development check reads, from the one function\n    // that gives it: a boundary with a reading of its own showed a learner a\n    // stack trace in every browser production build.\n    if (isDevelopment()) {\n      return (\n        <div role=\"alert\">\n          <strong>{(this.props.strings ?? DEFAULT_STRINGS).activityFailed}</strong>\n          <pre>{error.stack ?? error.message}</pre>\n        </div>\n      );\n    }\n\n    return (\n      <div role=\"alert\">\n        {this.props.activityTitle\n          ? (this.props.strings ?? DEFAULT_STRINGS).activityFailedNamed(this.props.activityTitle)\n          : (this.props.strings ?? DEFAULT_STRINGS).activityFailedUnnamed}\n      </div>\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;AA4BA,IAAa,wBAAb,cAA2CA,MAAAA,UAGzC;CACA,QAAoC,EAAE,OAAO,KAAK;CAElD,OAAO,yBAAyB,OAA0C;EACxE,OAAO,EAAE,MAAM;CACjB;CAEA,SAAoB;EAClB,MAAM,EAAE,UAAU,KAAK;EACvB,IAAI,CAAC,OACH,OAAO,KAAK,MAAM;EAMpB,IAAIC,kBAAAA,cAAc,GAChB,OACE,iBAAA,GAAA,kBAAA,KAAA,CAAC,OAAD;GAAK,MAAK;GAAV,UAAA,CACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,UAAD,EAAA,WAAU,KAAK,MAAM,WAAWC,uBAAAA,gBAAAA,CAAiB,eAAuB,CAAA,GACxE,iBAAA,GAAA,kBAAA,IAAA,CAAC,OAAD,EAAA,UAAM,MAAM,SAAS,MAAM,QAAa,CAAA,CACrC;;EAIT,OACE,iBAAA,GAAA,kBAAA,IAAA,CAAC,OAAD;GAAK,MAAK;GACP,UAAA,KAAK,MAAM,iBACP,KAAK,MAAM,WAAWA,uBAAAA,gBAAAA,CAAiB,oBAAoB,KAAK,MAAM,aAAa,KACnF,KAAK,MAAM,WAAWA,uBAAAA,gBAAAA,CAAiB;EACzC,CAAA;CAET;AACF"}

package/dist/ActivityErrorBoundary-Dw6SbWv3.js

@@ -0,0 +1,34 @@
+'use client';
+import { c as isDevelopment } from "./useAiHelp-B-ccDL5Q.js";
+import { a as DEFAULT_STRINGS } from "./LkIntlProvider-D_FdYXjQ.js";
+import { Component } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/ActivityErrorBoundary.tsx
+/**
+* Catches render errors in an activity subtree. In development it renders the
+* full error stack to aid debugging; in production it renders an accessible,
+* generic fallback (optionally naming the activity) so a single broken
+* activity never crashes the host application.
+*/
+var ActivityErrorBoundary = class extends Component {
+	state = { error: null };
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	render() {
+		const { error } = this.state;
+		if (!error) return this.props.children;
+		if (isDevelopment()) return /* @__PURE__ */ jsxs("div", {
+			role: "alert",
+			children: [/* @__PURE__ */ jsx("strong", { children: (this.props.strings ?? DEFAULT_STRINGS).activityFailed }), /* @__PURE__ */ jsx("pre", { children: error.stack ?? error.message })]
+		});
+		return /* @__PURE__ */ jsx("div", {
+			role: "alert",
+			children: this.props.activityTitle ? (this.props.strings ?? DEFAULT_STRINGS).activityFailedNamed(this.props.activityTitle) : (this.props.strings ?? DEFAULT_STRINGS).activityFailedUnnamed
+		});
+	}
+};
+//#endregion
+export { ActivityErrorBoundary as t };
+
+//# sourceMappingURL=ActivityErrorBoundary-Dw6SbWv3.js.map

package/dist/ActivityErrorBoundary-Dw6SbWv3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityErrorBoundary-Dw6SbWv3.js","names":[],"sources":["../src/components/ActivityErrorBoundary.tsx"],"sourcesContent":["'use client';\n\nimport { Component, type ReactNode } from 'react';\nimport type { LkStrings } from '../i18n/strings.js';\nimport { DEFAULT_STRINGS } from '../i18n/strings.js';\nimport { isDevelopment } from './_internal.js';\n\nexport interface ActivityErrorBoundaryProps {\n  /** Shown in the production fallback when a render error occurs. */\n  activityTitle?: string;\n  /**\n   * Chrome text. A class component cannot call `useLkStrings`, so the public\n   * wrapper reads the hook and hands the resolved dictionary down.\n   */\n  strings?: LkStrings;\n  children: ReactNode;\n}\n\ninterface ActivityErrorBoundaryState {\n  error: Error | null;\n}\n\n/**\n * Catches render errors in an activity subtree. In development it renders the\n * full error stack to aid debugging; in production it renders an accessible,\n * generic fallback (optionally naming the activity) so a single broken\n * activity never crashes the host application.\n */\nexport class ActivityErrorBoundary extends Component<\n  ActivityErrorBoundaryProps,\n  ActivityErrorBoundaryState\n> {\n  state: ActivityErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): ActivityErrorBoundaryState {\n    return { error };\n  }\n\n  render(): ReactNode {\n    const { error } = this.state;\n    if (!error) {\n      return this.props.children;\n    }\n\n    // The same answer every development check reads, from the one function\n    // that gives it: a boundary with a reading of its own showed a learner a\n    // stack trace in every browser production build.\n    if (isDevelopment()) {\n      return (\n        <div role=\"alert\">\n          <strong>{(this.props.strings ?? DEFAULT_STRINGS).activityFailed}</strong>\n          <pre>{error.stack ?? error.message}</pre>\n        </div>\n      );\n    }\n\n    return (\n      <div role=\"alert\">\n        {this.props.activityTitle\n          ? (this.props.strings ?? DEFAULT_STRINGS).activityFailedNamed(this.props.activityTitle)\n          : (this.props.strings ?? DEFAULT_STRINGS).activityFailedUnnamed}\n      </div>\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;AA4BA,IAAa,wBAAb,cAA2C,UAGzC;CACA,QAAoC,EAAE,OAAO,KAAK;CAElD,OAAO,yBAAyB,OAA0C;EACxE,OAAO,EAAE,MAAM;CACjB;CAEA,SAAoB;EAClB,MAAM,EAAE,UAAU,KAAK;EACvB,IAAI,CAAC,OACH,OAAO,KAAK,MAAM;EAMpB,IAAI,cAAc,GAChB,OACE,qBAAC,OAAD;GAAK,MAAK;GAAV,UAAA,CACE,oBAAC,UAAD,EAAA,WAAU,KAAK,MAAM,WAAW,gBAAA,CAAiB,eAAuB,CAAA,GACxE,oBAAC,OAAD,EAAA,UAAM,MAAM,SAAS,MAAM,QAAa,CAAA,CACrC;;EAIT,OACE,oBAAC,OAAD;GAAK,MAAK;GACP,UAAA,KAAK,MAAM,iBACP,KAAK,MAAM,WAAW,gBAAA,CAAiB,oBAAoB,KAAK,MAAM,aAAa,KACnF,KAAK,MAAM,WAAW,gBAAA,CAAiB;EACzC,CAAA;CAET;AACF"}