@bitflow/core 0.5.2 → 0.5.3

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Mike Barkmin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bits.d.ts

@@ -0,0 +1,128 @@
+import { ForwardRefExoticComponent, ReactElement, RefAttributes } from "react";
+import { ZodSchema } from "zod";
+import { DoResult } from "./do";
+export interface Action {
+    type: string;
+    payload?: any;
+}
+export interface FeedbackMessage {
+    message: string;
+    severity: "error" | "warning" | "info" | "success";
+}
+export interface TitleProps<T extends Bitflow.Title> {
+    title: Pick<T, "view" | "subtype">;
+}
+export interface TitleViewFormProps {
+    name: string;
+}
+export interface TitleBit<T extends Bitflow.Title = any> {
+    ViewForm: (props: TitleViewFormProps) => ReactElement | null;
+    Title: (props: TitleProps<T>) => ReactElement | null;
+    TitleSchema: ZodSchema<T>;
+    useInformation: () => {
+        name: string;
+        description: string;
+        example: T;
+    };
+}
+export interface InputProps<I extends Bitflow.Input> {
+    input: Pick<I, "view" | "subtype">;
+}
+export interface InputViewFormProps {
+    name: string;
+}
+export interface InputBit<I extends Bitflow.Input = any> {
+    ViewForm: (props: InputViewFormProps) => ReactElement | null;
+    Input: (props: InputProps<I>) => ReactElement | null;
+    useInformation: () => {
+        name: string;
+        description: string;
+        example: I;
+    };
+    InputSchema: ZodSchema<I>;
+}
+export interface StartProps<S extends Bitflow.Start> {
+    start: Pick<S, "view" | "subtype">;
+}
+export interface StartViewFormProps {
+    name: string;
+}
+export interface StartBit<S extends Bitflow.Start = any> {
+    ViewForm: (props: StartViewFormProps) => ReactElement | null;
+    Start: (props: StartProps<S>) => ReactElement | null;
+    StartSchema: ZodSchema<S>;
+    useInformation: () => {
+        name: string;
+        description: string;
+        example: S;
+    };
+}
+export interface EndProps<E extends Bitflow.End> {
+    end: Pick<E, "view" | "subtype">;
+    getResult: () => Promise<DoResult>;
+}
+export interface EndViewFormProps {
+    name: string;
+}
+export interface EndBit<E extends Bitflow.End = any> {
+    ViewForm: (props: EndViewFormProps) => ReactElement | null;
+    End: (props: EndProps<E>) => ReactElement | null;
+    useInformation: () => {
+        name: string;
+        description: string;
+        example: E;
+    };
+    EndSchema: ZodSchema<E>;
+}
+export interface TaskProps<T extends Bitflow.Task, R extends Bitflow.TaskResult, A extends Bitflow.TaskAnswer, Act extends Action> {
+    mode: "default" | "recording" | "result";
+    task: Pick<T, "view" | "subtype">;
+    result?: R;
+    answer?: A;
+    onChange?: (value: A) => void;
+    onAction?: (action: Act) => void;
+}
+export interface TaskRef<Act> {
+    dispatch: (action: Act) => void;
+}
+export interface TaskEvaluationFormProps {
+    name: string;
+}
+export interface TaskViewFormProps {
+    name: string;
+}
+export interface TaskFeedbackFormProps {
+    name: string;
+}
+export interface TaskStatisticProps<S extends Bitflow.TaskStatistic, T extends Bitflow.Task> {
+    statistic: S;
+    task: T;
+}
+export interface TaskEvaluateParams<A extends Bitflow.TaskAnswer, T extends Bitflow.Task> {
+    answer?: A;
+    task: T;
+}
+export declare type Evaluate<A extends Bitflow.TaskAnswer = Bitflow.TaskAnswer, T extends Bitflow.Task = Bitflow.Task, R extends Bitflow.TaskResult = Bitflow.TaskResult> = ({ answer, task }: TaskEvaluateParams<A, T>) => Promise<R>;
+export interface UpdateTaskStatisticParams<S extends Bitflow.TaskStatistic, A extends Bitflow.TaskAnswer, T extends Bitflow.Task, R extends Bitflow.TaskResult> {
+    statistic?: S;
+    answer: A;
+    task: T;
+    result?: R;
+}
+export declare type UpdateTaskStatistic<S extends Bitflow.TaskStatistic, A extends Bitflow.TaskAnswer, T extends Bitflow.Task, R extends Bitflow.TaskResult> = ({ statistic, answer, task, result, }: UpdateTaskStatisticParams<S, A, T, R>) => Promise<S>;
+export interface TaskBit<T extends Bitflow.Task = any, A extends Bitflow.TaskAnswer = any, R extends Bitflow.TaskResult = any, S extends Bitflow.TaskStatistic = any, Act extends Action = any> {
+    ViewForm: (props: TaskViewFormProps) => ReactElement | null;
+    EvaluationForm: (props: TaskEvaluationFormProps) => ReactElement | null;
+    FeedbackForm: (props: TaskFeedbackFormProps) => ReactElement | null;
+    Task: ForwardRefExoticComponent<TaskProps<T, R, A, Act> & RefAttributes<TaskRef<Act>>>;
+    Statistic: (props: TaskStatisticProps<S, T>) => ReactElement | null;
+    updateStatistic: UpdateTaskStatistic<S, A, T, R>;
+    TaskSchema: ZodSchema<T>;
+    useInformation: () => {
+        name: string;
+        description: string;
+        example: T;
+    };
+    evaluate: Evaluate<A, T, R>;
+}
+export declare const makeEvaluate: (evaluateMap: Record<string, Evaluate>) => Evaluate;

package/dist/bitsSchema.d.ts

@@ -0,0 +1,150 @@
+import * as z from "zod";
+export declare const FeedbackMessageSchema: z.ZodObject<{
+    message: z.ZodString;
+    severity: z.ZodEnum<["error", "warning", "info", "success"]>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    severity: "error" | "warning" | "info" | "success";
+}, {
+    message: string;
+    severity: "error" | "warning" | "info" | "success";
+}>;
+export declare const TaskSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    subtype: z.ZodString;
+    view: z.ZodRecord<z.ZodString, z.ZodAny>;
+    evaluation: z.ZodObject<{
+        mode: z.ZodEnum<["auto", "skip", "manual"]>;
+        enableRetry: z.ZodBoolean;
+        showFeedback: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        mode: "auto" | "manual" | "skip";
+        enableRetry: boolean;
+        showFeedback: boolean;
+    }, {
+        mode: "auto" | "manual" | "skip";
+        enableRetry: boolean;
+        showFeedback: boolean;
+    }>;
+    feedback: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
+    feedback?: Record<string, any> | undefined;
+    view: Record<string, any>;
+    subtype: string;
+    name: string;
+    evaluation: {
+        mode: "auto" | "manual" | "skip";
+        enableRetry: boolean;
+        showFeedback: boolean;
+    };
+}, {
+    description?: string | undefined;
+    feedback?: Record<string, any> | undefined;
+    view: Record<string, any>;
+    subtype: string;
+    name: string;
+    evaluation: {
+        mode: "auto" | "manual" | "skip";
+        enableRetry: boolean;
+        showFeedback: boolean;
+    };
+}>;
+export declare const TaskStatisticSchema: z.ZodObject<{
+    subtype: z.ZodString;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    subtype: string;
+    count: number;
+}, {
+    subtype: string;
+    count: number;
+}>;
+export declare const TaskAnswerSchema: z.ZodObject<{
+    subtype: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    subtype: string;
+}, {
+    subtype: string;
+}>;
+export declare const TaskResultSchema: z.ZodObject<{
+    subtype: z.ZodString;
+    state: z.ZodEnum<["unknown", "manual", "correct", "wrong"]>;
+    allowRetry: z.ZodOptional<z.ZodBoolean>;
+    feedback: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    feedback?: any;
+    allowRetry?: boolean | undefined;
+    subtype: string;
+    state: "manual" | "unknown" | "correct" | "wrong";
+}, {
+    feedback?: any;
+    allowRetry?: boolean | undefined;
+    subtype: string;
+    state: "manual" | "unknown" | "correct" | "wrong";
+}>;
+export declare const InputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    subtype: z.ZodString;
+    view: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}>;
+export declare const TitleSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    subtype: z.ZodString;
+    view: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}>;
+export declare const StartSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    subtype: z.ZodString;
+    view: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}>;
+export declare const EndSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    subtype: z.ZodString;
+    view: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, "strip", z.ZodTypeAny, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}, {
+    view: {};
+    subtype: string;
+    name: string;
+    description: string;
+}>;

package/dist/do.d.ts

@@ -0,0 +1,37 @@
+import { InteractiveFlowPublicNode } from "./flow";
+export interface DoBaseTry {
+    node: InteractiveFlowPublicNode;
+    startDate: Date;
+    try: number;
+    status: string;
+}
+export interface DoStartedTry extends DoBaseTry {
+    status: "started";
+}
+export declare const isDoStartedTry: (d: DoTry) => d is DoStartedTry;
+export interface DoFinishedTry extends DoBaseTry {
+    status: "finished";
+    endDate: Date;
+    answer?: Bitflow.TaskAnswer;
+    result?: Bitflow.TaskResult;
+}
+export declare const isDoFinishedTry: (d: DoTry) => d is DoFinishedTry;
+export interface DoSkippedTry extends DoBaseTry {
+    status: "skipped";
+    evaluation: {
+        mode: "auto" | "manual" | "skip";
+    };
+    endDate: Date;
+}
+export declare const isDoSkippedTry: (d: DoTry) => d is DoSkippedTry;
+export declare type DoTry = DoStartedTry | DoSkippedTry | DoFinishedTry;
+export declare const skipDoTry: (doResult: DoResult, evaluation?: DoSkippedTry["evaluation"]) => DoResult;
+export interface DoResult {
+    points: number;
+    maxPoints: number;
+    startDate: Date;
+    endDate: Date;
+    tries: DoTry[];
+}
+export declare const finishDoTry: (doResult: DoResult, answer?: Bitflow.TaskAnswer | undefined, result?: Bitflow.TaskResult | undefined) => DoResult;
+export declare const retryDoTry: (doResult: DoResult) => DoResult;