@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/ai/useAiHelp.d.cts

@@ -1,96 +1,94 @@
-import { AiCoaching, ReadAloudData, SpeechAssessment, GradeRecord, InteractionEvent, DeliveryPolicy, AiTextResult, LearnerResponse, ItemOutcome, AiWritingFeedback } from '@intellectif/lk-core';
-import { e as RenderMode, g as RenderableActivity } from '../types-CJgZWtl4.cjs';
-import { LearnerAi } from './LkAiProvider.cjs';
-import '../machine-CuwKqWXC.cjs';
-import 'react';
-
+import { t as LearnerAi } from "../LkAiProvider-DAPpA3PQ.cjs";
+import { a as RenderMode, s as RenderableActivity } from "../types-BOQd93x3.cjs";
+import { AiCoaching, AiTextResult, AiWritingFeedback, DeliveryPolicy, GradeRecord, InteractionEvent, ItemOutcome, LearnerResponse, ReadAloudData, SpeechAssessment } from "@intellectif/lk-core";
+//#region src/ai/useAiHelp.d.ts
 /**
  * The question AI help is being asked about, as the SDK's own components know
  * it. A host drawing its own question passes what it has; everything optional
  * defaults to what the components pass.
  */
-interface AiHelpSituation {
-    /** The question, as `data` is given to any activity component. */
-    data: RenderableActivity;
-    /** The learner's answer as it stands: submitted, restored, or being written. */
-    response: LearnerResponse;
-    /** Whether the learner has committed that answer. */
-    submitted: boolean;
-    /**
-     * Pass on the `renderMode` your question was given. Left out, the paper
-     * around the question answers for it — a question inside `<ActivitySequence>`
-     * or `<InteractiveVideo>` knows its mode — and `practice` only where there is
-     * no paper at all. An `exam` around the question wins over anything passed
-     * here.
-     */
-    renderMode?: RenderMode;
-    /**
-     * The AI ports to use, overriding {@link LkAiProvider}'s for this question.
-     * A question inside `<ActivitySequence>` or `<InteractiveVideo>` is handed
-     * the ports in force as `ai` — pass that straight in.
-     */
-    ai?: LearnerAi;
-    /** The interface language: the default language for what a model writes. */
-    locale?: string;
-    /** Where `ai-hint-shown` and `ai-explanation-shown` go. */
-    onInteraction?: (event: InteractionEvent) => void;
-    /**
-     * The delivery policy your question was handed. The paper around the
-     * question holds as well — a set that switched AI hints off keeps them off
-     * here, whatever is passed — so leaving it out never turns anything on.
-     */
-    delivery?: DeliveryPolicy | null;
+export interface AiHelpSituation {
+  /** The question, as `data` is given to any activity component. */
+  data: RenderableActivity;
+  /** The learner's answer as it stands: submitted, restored, or being written. */
+  response: LearnerResponse;
+  /** Whether the learner has committed that answer. */
+  submitted: boolean;
+  /**
+   * Pass on the `renderMode` your question was given. Left out, the paper
+   * around the question answers for it — a question inside `<ActivitySequence>`
+   * or `<InteractiveVideo>` knows its mode — and `practice` only where there is
+   * no paper at all. An `exam` around the question wins over anything passed
+   * here.
+   */
+  renderMode?: RenderMode;
+  /**
+   * The AI ports to use, overriding {@link LkAiProvider}'s for this question.
+   * A question inside `<ActivitySequence>` or `<InteractiveVideo>` is handed
+   * the ports in force as `ai` — pass that straight in.
+   */
+  ai?: LearnerAi;
+  /** The interface language: the default language for what a model writes. */
+  locale?: string;
+  /** Where `ai-hint-shown` and `ai-explanation-shown` go. */
+  onInteraction?: (event: InteractionEvent) => void;
+  /**
+   * The delivery policy your question was handed. The paper around the
+   * question holds as well — a set that switched AI hints off keeps them off
+   * here, whatever is passed — so leaving it out never turns anything on.
+   */
+  delivery?: DeliveryPolicy | null;
 }
-interface AiExplanationInput extends AiHelpSituation {
-    /** The grade of record, which `review` explains. */
-    outcome?: ItemOutcome;
+export interface AiExplanationInput extends AiHelpSituation {
+  /** The grade of record, which `review` explains. */
+  outcome?: ItemOutcome;
 }
-interface AiExplanationHelp {
-    /**
-     * Whether to offer the learner an explanation at all: a port is present, the
-     * answer is graded, the type is one the SDK explains, and the author left
-     * explanations on. False in `exam`, always.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'shown' | 'unavailable';
-    /** What to show, once it has arrived and been checked. Its `text` is text, never HTML. */
-    explanation: AiTextResult | null;
-    /**
-     * Asks the port, when the learner presses something. Does nothing while a
-     * call is on its way, and nothing at all where `offered` is false — so an
-     * exam cannot reach a model through this hook, whatever ports are in scope.
-     *
-     * One identity for the life of the question, so it is safe in an effect's
-     * dependencies.
-     */
-    ask: () => void;
+export interface AiExplanationHelp {
+  /**
+   * Whether to offer the learner an explanation at all: a port is present, the
+   * answer is graded, the type is one the SDK explains, and the author left
+   * explanations on. False in `exam`, always.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'shown' | 'unavailable';
+  /** What to show, once it has arrived and been checked. Its `text` is text, never HTML. */
+  explanation: AiTextResult | null;
+  /**
+   * Asks the port, when the learner presses something. Does nothing while a
+   * call is on its way, and nothing at all where `offered` is false — so an
+   * exam cannot reach a model through this hook, whatever ports are in scope.
+   *
+   * One identity for the life of the question, so it is safe in an effect's
+   * dependencies.
+   */
+  ask: () => void;
 }
-interface AiHintsInput extends AiHelpSituation {
-    /** A disabled question gives no hints, as it takes no answer. */
-    disabled?: boolean;
+export interface AiHintsInput extends AiHelpSituation {
+  /** A disabled question gives no hints, as it takes no answer. */
+  disabled?: boolean;
 }
-interface AiHintsHelp {
-    /**
-     * Whether the learner may ask for hints here at all: a port is present, the
-     * mode is `practice`, the answer is not in, the question is not disabled or
-     * redacted, the type takes hints and the author left them on. It stays true
-     * once `used` reaches `limit` — there are no more to give, but the question
-     * is still one that gives them.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'unavailable';
-    /** Every hint shown for this question, in the order they were given. */
-    hints: readonly AiTextResult[];
-    /** The host's `maxHints`, as a whole number from 1 to 10 (3 by default). */
-    limit: number;
-    /** How many hints have been shown. A refused hint is not counted. */
-    used: number;
-    /**
-     * Asks for the next hint. Does nothing at the limit, while a call is on its
-     * way, or where `offered` is false. One identity for the life of the
-     * question.
-     */
-    ask: () => void;
+export interface AiHintsHelp {
+  /**
+   * Whether the learner may ask for hints here at all: a port is present, the
+   * mode is `practice`, the answer is not in, the question is not disabled or
+   * redacted, the type takes hints and the author left them on. It stays true
+   * once `used` reaches `limit` — there are no more to give, but the question
+   * is still one that gives them.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'unavailable';
+  /** Every hint shown for this question, in the order they were given. */
+  hints: readonly AiTextResult[];
+  /** The host's `maxHints`, as a whole number from 1 to 10 (3 by default). */
+  limit: number;
+  /** How many hints have been shown. A refused hint is not counted. */
+  used: number;
+  /**
+   * Asks for the next hint. Does nothing at the limit, while a call is on its
+   * way, or where `offered` is false. One identity for the life of the
+   * question.
+   */
+  ask: () => void;
 }
 /**
  * "Explain my answer", without the SDK's own button and panel: the rules, the
@@ -124,7 +122,7 @@ interface AiHintsHelp {
  * still on its way is abandoned — a late explanation never lands beside an
  * answer it was not written for — as it is when the caller unmounts.
  */
-declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
+export declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
 /**
  * "Get a hint", without the SDK's own button and list: the rules, the call, the
  * checks and the record, for a question you draw yourself.
@@ -147,40 +145,40 @@ declare function useAiExplanation(input: AiExplanationInput): AiExplanationHelp;
  * Keep the hints on screen after submit — the learner can see what they were
  * given — while `offered` turns false. Another question starts with none.
  */
-declare function useAiHints(input: AiHintsInput): AiHintsHelp;
-interface AiWritingFeedbackInput extends AiHelpSituation {
-    /** A disabled question takes no feedback, as it takes no answer. */
-    disabled?: boolean;
+export declare function useAiHints(input: AiHintsInput): AiHintsHelp;
+export interface AiWritingFeedbackInput extends AiHelpSituation {
+  /** A disabled question takes no feedback, as it takes no answer. */
+  disabled?: boolean;
 }
-interface AiWritingFeedbackHelp {
-    /**
-     * Whether the learner may ask for feedback here at all: a port is present,
-     * the mode is `practice`, the answer is not in, the question is a written
-     * response that is not disabled or redacted, its author left explanations on,
-     * and the paper shows feedback and solutions and allows AI explanations. It
-     * stays true once `used` reaches `limit`.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'unavailable';
-    /** Every piece of feedback shown for this question, oldest first. */
-    feedback: readonly AiWritingFeedback[];
-    /** The latest, or `null` before any. Its `text` is text, never HTML. */
-    latest: AiWritingFeedback | null;
-    /**
-     * Whether `latest` is about the draft as it stands. Once the learner revises,
-     * its corrections point at words that may no longer be there: say so.
-     */
-    current: boolean;
-    /** The host's `maxWritingFeedback`, as a whole number from 1 to 10 (3 by default). */
-    limit: number;
-    /** How many times feedback has been shown. A refused reply is not counted. */
-    used: number;
-    /**
-     * Asks for feedback on the draft as it stands. Does nothing at the limit,
-     * while a call is on its way, on an empty draft, or where `offered` is false.
-     * One identity for the life of the question.
-     */
-    ask: () => void;
+export interface AiWritingFeedbackHelp {
+  /**
+   * Whether the learner may ask for feedback here at all: a port is present,
+   * the mode is `practice`, the answer is not in, the question is a written
+   * response that is not disabled or redacted, its author left explanations on,
+   * and the paper shows feedback and solutions and allows AI explanations. It
+   * stays true once `used` reaches `limit`.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'unavailable';
+  /** Every piece of feedback shown for this question, oldest first. */
+  feedback: readonly AiWritingFeedback[];
+  /** The latest, or `null` before any. Its `text` is text, never HTML. */
+  latest: AiWritingFeedback | null;
+  /**
+   * Whether `latest` is about the draft as it stands. Once the learner revises,
+   * its corrections point at words that may no longer be there: say so.
+   */
+  current: boolean;
+  /** The host's `maxWritingFeedback`, as a whole number from 1 to 10 (3 by default). */
+  limit: number;
+  /** How many times feedback has been shown. A refused reply is not counted. */
+  used: number;
+  /**
+   * Asks for feedback on the draft as it stands. Does nothing at the limit,
+   * while a call is on its way, on an empty draft, or where `offered` is false.
+   * One identity for the life of the question.
+   */
+  ask: () => void;
 }
 /**
  * "Get feedback on my draft", without the SDK's own button and panel: the
@@ -202,63 +200,63 @@ interface AiWritingFeedbackHelp {
  * mistakes." And show `indicativeScore` as what it is — an indication, not a
  * grade.
  */
-declare function useAiWritingFeedback(input: AiWritingFeedbackInput): AiWritingFeedbackHelp;
-interface AiCoachingInput {
-    /**
-     * The read-aloud item, as `data` is given to `<ReadAloud>` — or as much of
-     * one as coaching reads: its id, title, text and language, and the author's
-     * `instructions` and `ai` settings where it has them.
-     */
-    data: Pick<ReadAloudData, 'id' | 'title' | 'referenceText' | 'locale'> & Partial<Pick<ReadAloudData, 'instructions' | 'ai'>>;
-    /**
-     * The speech engine's assessment of the take, as the learner is shown it.
-     * When given, it is the marks — each word's, with its sounds and what each
-     * was heard as — and the only ones: see `aiCoachingRequest` in lk-core.
-     */
-    assessment?: SpeechAssessment | null;
-    /**
-     * The grade of record. Its score is context for the model; without an
-     * assessment, its word details are the marks, and they carry no sounds.
-     */
-    grade?: GradeRecord | null;
-    /**
-     * Pass on the `renderMode` your reading was given. Coaching is never offered
-     * in `exam`, and an `exam` around the reading wins over anything passed here.
-     */
-    renderMode?: RenderMode;
-    /** The AI ports to use, overriding {@link LkAiProvider}'s for this reading. */
-    ai?: LearnerAi;
-    /** The interface language: the default language for what a model writes. */
-    locale?: string;
-    /** Where `ai-coaching-shown` and `ai-help-refused` go. */
-    onInteraction?: (event: InteractionEvent) => void;
-    /**
-     * The delivery policy your reading was handed. Coaching needs feedback shown
-     * and AI explanations allowed; the paper around the reading holds as well.
-     */
-    delivery?: DeliveryPolicy | null;
+export declare function useAiWritingFeedback(input: AiWritingFeedbackInput): AiWritingFeedbackHelp;
+export interface AiCoachingInput {
+  /**
+   * The read-aloud item, as `data` is given to `<ReadAloud>` — or as much of
+   * one as coaching reads: its id, title, text and language, and the author's
+   * `instructions` and `ai` settings where it has them.
+   */
+  data: Pick<ReadAloudData, 'id' | 'title' | 'referenceText' | 'locale'> & Partial<Pick<ReadAloudData, 'instructions' | 'ai'>>;
+  /**
+   * The speech engine's assessment of the take, as the learner is shown it.
+   * When given, it is the marks — each word's, with its sounds and what each
+   * was heard as — and the only ones: see `aiCoachingRequest` in lk-core.
+   */
+  assessment?: SpeechAssessment | null;
+  /**
+   * The grade of record. Its score is context for the model; without an
+   * assessment, its word details are the marks, and they carry no sounds.
+   */
+  grade?: GradeRecord | null;
+  /**
+   * Pass on the `renderMode` your reading was given. Coaching is never offered
+   * in `exam`, and an `exam` around the reading wins over anything passed here.
+   */
+  renderMode?: RenderMode;
+  /** The AI ports to use, overriding {@link LkAiProvider}'s for this reading. */
+  ai?: LearnerAi;
+  /** The interface language: the default language for what a model writes. */
+  locale?: string;
+  /** Where `ai-coaching-shown` and `ai-help-refused` go. */
+  onInteraction?: (event: InteractionEvent) => void;
+  /**
+   * The delivery policy your reading was handed. Coaching needs feedback shown
+   * and AI explanations allowed; the paper around the reading holds as well.
+   */
+  delivery?: DeliveryPolicy | null;
 }
-interface AiCoachingHelp {
-    /**
-     * Whether to offer coaching at all: a `pronunciationCoaching` port is
-     * present, there are marks to coach, the mode is not `exam`, the item's
-     * author left explanations on, and the paper shows feedback and allows AI
-     * explanations.
-     */
-    offered: boolean;
-    status: 'idle' | 'loading' | 'shown' | 'unavailable';
-    /**
-     * What to show, once it has arrived and been checked: the coaching's text,
-     * and the words it works on in reading order, each with its tip and, where
-     * the engine reported one, the sound. All of it is text, never HTML.
-     */
-    coaching: AiCoaching | null;
-    /**
-     * Asks the port, when the learner presses something. Does nothing while a
-     * call is on its way, once coaching is shown — one per reading — or where
-     * `offered` is false. One identity for the life of the reading.
-     */
-    ask: () => void;
+export interface AiCoachingHelp {
+  /**
+   * Whether to offer coaching at all: a `pronunciationCoaching` port is
+   * present, there are marks to coach, the mode is not `exam`, the item's
+   * author left explanations on, and the paper shows feedback and allows AI
+   * explanations.
+   */
+  offered: boolean;
+  status: 'idle' | 'loading' | 'shown' | 'unavailable';
+  /**
+   * What to show, once it has arrived and been checked: the coaching's text,
+   * and the words it works on in reading order, each with its tip and, where
+   * the engine reported one, the sound. All of it is text, never HTML.
+   */
+  coaching: AiCoaching | null;
+  /**
+   * Asks the port, when the learner presses something. Does nothing while a
+   * call is on its way, once coaching is shown — one per reading — or where
+   * `offered` is false. One identity for the life of the reading.
+   */
+  ask: () => void;
 }
 /**
  * "Coach me on this reading", without the SDK's own button and panel: the
@@ -281,6 +279,6 @@ interface AiCoachingHelp {
  * Another reading — other marks, another text — drops the coaching and
  * abandons a call still on its way, as the caller unmounting does.
  */
-declare function useAiCoaching(input: AiCoachingInput): AiCoachingHelp;
-
-export { type AiCoachingHelp, type AiCoachingInput, type AiExplanationHelp, type AiExplanationInput, type AiHelpSituation, type AiHintsHelp, type AiHintsInput, type AiWritingFeedbackHelp, type AiWritingFeedbackInput, useAiCoaching, useAiExplanation, useAiHints, useAiWritingFeedback };
+export declare function useAiCoaching(input: AiCoachingInput): AiCoachingHelp;
+//#endregion
+//# sourceMappingURL=useAiHelp.d.cts.map

package/dist/ai/useAiHelp.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAiHelp.d.cts","names":[],"sources":["../../src/ai/useAiHelp.ts"],"mappings":";;;;;;;;;iBA6CiB;;EAEf,MAAM;;EAEN,UAAU;;EAEV;;;;;;;;EAQA,aAAa;;;;;;EAMb,KAAK;;EAEL;;EAEA,iBAAiB,OAAO;;;;;;EAMxB,WAAW;;iBAGI,2BAA2B;;EAE1C,UAAU;;iBAGK;;;;;;EAMf;EACA;;EAEA,aAAa;;;;;;;;;EASb;;iBAGe,qBAAqB;;EAEpC;;iBAGe;;;;;;;;EAQf;EACA;;EAEA,gBAAgB;;EAEhB;;EAEA;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwEc,iBAAiB,OAAO,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;wBA8H7C,WAAW,OAAO,eAAe;iBA2HhC,+BAA+B;;EAE9C;;iBAGe;;;;;;;;EAQf;EACA;;EAEA,mBAAmB;;EAEnB,QAAQ;;;;;EAKR;;EAEA;;EAEA;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;wBAiCc,qBAAqB,OAAO,yBAAyB;iBA4IpD;;;;;;EAMf,MAAM,KAAK,8DACT,QAAQ,KAAK;;;;;;EAMf,aAAa;;;;;EAKb,QAAQ;;;;;EAKR,aAAa;;EAEb,KAAK;;EAEL;;EAEA,iBAAiB,OAAO;;;;;EAKxB,WAAW;;iBAGI;;;;;;;EAOf;EACA;;;;;;EAMA,UAAU;;;;;;EAMV;;;;;;;;;;;;;;;;;;;;;;;wBA4Bc,cAAc,OAAO,kBAAkB"}