@media-quest/engine 0.0.26 → 0.0.27

package/dist/public-api.d.ts

@@ -0,0 +1,510 @@
+type Fact = Fact.Numeric | Fact.String;
+declare namespace Fact {
+    interface Numeric {
+        readonly kind: "numeric-fact";
+        readonly value: number;
+        readonly label: string;
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+    }
+    interface String {
+        readonly kind: "string-fact";
+        readonly label: string;
+        readonly value: string;
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+    }
+}
+
+type DTimestamp = number & {
+    __timestamp__: true;
+};
+declare namespace DTimestamp {
+    const now: () => DTimestamp;
+    type Diff = number & {
+        __diff__: true;
+    };
+    const addMills: (t: DTimestamp, ms: number) => DTimestamp;
+    const diff: (t1: DTimestamp, t2: DTimestamp) => Diff;
+    const diffNow: (t: DTimestamp) => Diff;
+}
+
+interface _MqEvent<K extends string, P extends object> {
+    readonly kind: K;
+    readonly timestamp: DTimestamp;
+    readonly payload: P;
+}
+type MqEventEngineStart = _MqEvent<"engine-start", {
+    readonly schemaId: string;
+    readonly schemaPrefix: string;
+}>;
+interface MqEventPageEnter extends _MqEvent<"page-enter", {
+    readonly pageId: string;
+    readonly pagePrefix: string;
+}> {
+}
+interface MqEventPageLeave extends _MqEvent<"page-leave", {
+    readonly pageId: string;
+    readonly pagePrefix: string;
+}> {
+}
+type MqEventUserClicked = _MqEvent<"user-clicked", {
+    readonly pageId: string;
+    pagePrefix: string;
+    action: string;
+    descriptions: string;
+}>;
+type MqEvent = MqEventPageEnter | MqEventPageLeave | MqEventEngineStart | MqEventUserClicked;
+declare const MqEvent: {
+    readonly engineStart: (schemaId: string, schemaPrefix: string) => MqEventEngineStart;
+    readonly pageEnter: (pageId: string, pagePrefix: string) => MqEventPageEnter;
+    readonly pageLeave: (pageId: string, pagePrefix: string) => MqEventPageLeave;
+    readonly userClicked: (data: {
+        pageId: string;
+        pagePrefix: string;
+        action: string;
+        descriptions: string;
+    }) => MqEventUserClicked;
+};
+
+interface SchemaResult {
+    readonly schemaId: string;
+    readonly pagesLeft: number;
+    readonly predefinedFacts: ReadonlyArray<Fact>;
+    readonly eventLog: ReadonlyArray<MqEvent>;
+    readonly answers: ReadonlyArray<Fact>;
+}
+
+type Condition = Condition.String | Condition.Numeric | Condition.Complex;
+declare namespace Condition {
+    type StringOperator = "eq" | "not-eq" | "longer-then" | "shorter-then";
+    type NumericOperator = "eq" | "not-eq" | "greater-then" | "less-then" | "greater-then-inclusive" | "less-then-inclusive";
+    interface Numeric {
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+        readonly valueLabel: string;
+        readonly kind: "numeric-condition";
+        readonly operator: NumericOperator;
+        readonly value: number;
+    }
+    interface String {
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+        readonly valueLabel: string;
+        readonly kind: "string-condition";
+        readonly operator: StringOperator;
+        readonly value: string;
+    }
+    interface Complex {
+        readonly kind: "complex-condition";
+        readonly name: string;
+        readonly all: ReadonlyArray<Condition.Simple>;
+        readonly some: ReadonlyArray<Condition.Simple>;
+    }
+    type Simple = Condition.String | Condition.Numeric;
+    /**
+     * An empty condition will evaluate to false,
+     * @param condition: Condition.Any
+     * @param facts
+     */
+    const evaluate: (condition: Condition, facts: ReadonlyArray<Fact>) => boolean;
+    const isEmpty: (complex: Complex) => boolean;
+    const getAllSimpleConditions: (condition: Condition | Array<Condition>) => ReadonlyArray<Condition.Simple>;
+}
+
+interface Rule<OnSuccessAction, OnFailureAction> {
+    readonly id?: string;
+    readonly description: string;
+    readonly all: ReadonlyArray<Condition>;
+    readonly some: ReadonlyArray<Condition>;
+    readonly onSuccess: ReadonlyArray<OnSuccessAction>;
+    readonly onFailure: ReadonlyArray<OnFailureAction>;
+}
+declare namespace Rule {
+    /**
+     * Validates that the rule is valid.
+     * @param rule
+     */
+    const isEmpty: (rule: Rule<any, any>) => boolean;
+    const solve: (rule: Rule<any, any>, facts: ReadonlyArray<Fact>) => boolean;
+}
+
+type RuleActionPageQue = {
+    kind: "excludeByTag";
+    tagIds: string[];
+} | {
+    kind: "excludeByPageId";
+    pageIds: Array<string>;
+} | {
+    kind: "jumpToPage";
+    pageId: string;
+};
+
+type BaseTask = {
+    readonly blockAudio: boolean;
+    readonly blockVideo: boolean;
+    readonly blockResponseButton: boolean;
+    readonly blockFormInput: boolean;
+    readonly priority: "run-if-idle" | "follow-queue" | "replace-all" | "replace-current" | "replace-queue" | "prepend-to-queue" | "append-to-queue";
+};
+type DelayTask = BaseTask & {
+    readonly kind: "delay-task";
+    readonly duration: number;
+};
+type PlayAudioTask = BaseTask & {
+    readonly kind: "play-audio-task";
+    readonly url: string;
+    readonly audioId: string;
+};
+type PlayVideoTask = BaseTask & {
+    readonly kind: "play-video-task";
+    readonly url: string;
+    readonly videoId: string;
+    readonly loop?: boolean;
+    readonly startAt?: number;
+    readonly stopAt?: "end" | "start" | number;
+    readonly volume?: number;
+};
+declare const Task: {
+    eq: (a: Task, b: Task) => boolean;
+    is: (task: Task | undefined | false | null | {}) => task is Task;
+    notEq: (a: Task, b: Task) => boolean;
+    deleteTaskList: (task: Task) => boolean;
+    shallRemoveCurrent: (task: Task) => boolean;
+};
+type Task = PlayVideoTask | PlayAudioTask | DelayTask;
+
+declare namespace DCss {
+    interface Px {
+        readonly _unit: "px";
+        readonly value: number;
+    }
+    type LengthString = `${number}px` | `${number}%`;
+    interface Percent {
+        readonly _unit: "percent";
+        readonly value: number;
+    }
+    type LengthUnit = Px | Percent;
+    /**
+     * Will scale to 3% of baseScale
+     * @param unit
+     * @param scale
+     */
+    const toString: (unit: Readonly<LengthUnit>, scale: number) => LengthString;
+    const isLengthUnit: (unit?: LengthUnit) => unit is LengthUnit;
+}
+
+type PStyle = Partial<DStyle>;
+interface DStyle {
+    opacity: number;
+    backgroundColor: string;
+    visibility: "visible" | "hidden";
+    cursor: "pointer" | "help" | "copy" | "wait" | "not-allowed" | "context-menu" | "move" | "grabbing" | "grab" | "zoom-in" | "zoom-out" | "none" | "auto" | "default";
+    h: number;
+    w: number;
+    x: number;
+    y: number;
+    borderStyle: "solid" | "none" | "dotted" | "dashed";
+    borderRadius: DCss.Px | DCss.Percent;
+    borderWidth: DCss.Px;
+    borderColor: string;
+    margin: DCss.Px | DCss.Percent;
+    padding: DCss.Px | DCss.Percent;
+    transform: string;
+    translate: string;
+    fontSize: DCss.Px;
+    textColor: string;
+    fontWeight: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+    textAlign: "right" | "left" | "center";
+    letterSpacing: DCss.Px;
+}
+declare namespace DStyle {
+    const normalize: <T extends HTMLElement>(el: T) => T;
+    const applyStyles: <T extends HTMLElement>(el: T, style: Partial<DStyle>, scale: number) => T;
+}
+
+declare class ScaleService {
+    private readonly baseHeight;
+    private readonly baseWidth;
+    private containerHeight;
+    private containerWidth;
+    get scale(): number;
+    get pageHeight(): number;
+    get pageWidth(): number;
+    private _scale;
+    private readonly subscribers;
+    constructor(config: {
+        baseHeight: number;
+        baseWidth: number;
+        containerHeight: number;
+        containerWidth: number;
+    });
+    setContainerBounds(bounds: {
+        height: number;
+        width: number;
+    }): void;
+    private updateScale;
+    onChange(scaleChangeHandler: (scale: number) => void, subscriberId: string): () => void;
+}
+
+type TaskStateDiff = Partial<TaskState> & {
+    __diffed__: true;
+};
+type TaskState = {
+    audioIsPlaying: boolean;
+    isGifMode: boolean;
+    videoIsPlaying: boolean;
+    blockFormInput: boolean;
+    blockResponseButton: boolean;
+    blockAudio: boolean;
+    blockVideo: boolean;
+};
+declare const TaskState: {
+    eq: (a: TaskState, b: TaskState) => boolean;
+    getDiff: (curr: TaskState, prev: TaskState | false) => TaskStateDiff;
+};
+
+type ButtonClickAction = {
+    kind: "play-audio";
+    task: PlayAudioTask;
+} | {
+    kind: "pause-audio";
+} | {
+    kind: "play-video";
+    task: PlayVideoTask;
+} | {
+    kind: "pause-video";
+} | {
+    kind: "submit-fact";
+    fact: Fact;
+} | {
+    kind: "next-page";
+} | {
+    kind: "submit-form";
+};
+declare const ButtonClickAction: {
+    describe: (a: ButtonClickAction) => string;
+};
+
+interface DElementBaseDto {
+    readonly style: PStyle;
+    readonly onMouseEnter?: PStyle;
+    readonly onMouseLeave?: PStyle;
+    readonly onMouseDown?: PStyle;
+    readonly onMouseUp?: PStyle;
+    readonly innerText?: string;
+}
+declare abstract class DElement<T extends HTMLElement> {
+    protected readonly el: T;
+    protected readonly dto: DElementBaseDto;
+    protected readonly scale: ScaleService;
+    protected currStyle: Partial<DStyle>;
+    protected constructor(el: T, dto: DElementBaseDto, scale: ScaleService);
+    /**
+     *  This method is called when the element is clicked.
+     *  This method shall be overridden by the pageClass.
+     * @param actions
+     */
+    onclick(): void;
+    setStyle(style: PStyle): void;
+    appendYourself(parent: {
+        append: (el: HTMLElement) => void;
+    }): void;
+    private normalize;
+    protected updateStyles(style: Partial<DStyle>): void;
+}
+
+interface DImgDto extends DElementBaseDto {
+    readonly _tag: "img";
+    readonly url: string;
+}
+declare class DImg extends DElement<HTMLImageElement> {
+    protected readonly dto: DImgDto;
+    readonly scaleService: ScaleService;
+    private static IMAGE_COUNT;
+    private readonly imageCount;
+    readonly TAG: string;
+    readonly TIMING_TAG: string;
+    private readonly loadStart;
+    constructor(dto: DImgDto, scaleService: ScaleService);
+    log(): void;
+}
+
+interface DTextDto extends DElementBaseDto {
+    readonly _tag: "p";
+    readonly innerText: string;
+}
+declare class DText extends DElement<HTMLParagraphElement> {
+    constructor(dto: DTextDto, scale: ScaleService);
+}
+
+interface DDivDto extends DElementBaseDto {
+    readonly _tag: "div";
+    readonly children: Array<DTextDto | DImgDto>;
+}
+declare class DDiv extends DElement<HTMLDivElement> {
+    private readonly TAG;
+    protected readonly defaultStyle: {
+        x: number;
+        y: number;
+    };
+    private children;
+    constructor(dto: DDivDto, scale: ScaleService, children: Array<DText | DImg>);
+}
+
+type DElementDto = DTextDto | DImgDto | DDivDto;
+
+interface PageComponentDto {
+    readonly onClick?: ButtonClickAction;
+    readonly el: DElementDto;
+    readonly whenVideoPlay?: PStyle;
+    readonly whenVideoPaused?: PStyle;
+    readonly whenAudioPlaying?: PStyle;
+    readonly whenAudioPaused?: PStyle;
+    readonly whenAudioBlocked?: PStyle;
+    readonly whenVideoBlocked?: PStyle;
+    readonly whenAudioUnblocked?: PStyle;
+    readonly whenVideoUnblocked?: PStyle;
+    readonly whenResponseBlocked?: PStyle;
+    readonly whenResponseUnblocked?: PStyle;
+    readonly whenFormInputBlocked?: PStyle;
+    readonly whenFormInputUnblocked?: PStyle;
+}
+declare class PageComponent {
+    readonly dto: PageComponentDto;
+    readonly scale: ScaleService;
+    private readonly TAG;
+    private el;
+    private prevState;
+    constructor(dto: PageComponentDto, scale: ScaleService);
+    onClick(action: ButtonClickAction): void;
+    updateState(state: TaskStateDiff): void;
+    setState(state: TaskState): void;
+    private handleStateChanges;
+    appendToParent(parent: {
+        append: (el: HTMLElement) => void;
+    }): void;
+}
+
+interface VideoPlayerDto {
+    playUrl: string;
+    style?: PStyle;
+}
+interface PageDto {
+    readonly id: string;
+    readonly prefix: string;
+    readonly tags: string[];
+    staticElements: Array<DElementDto>;
+    background: string;
+    components: Array<PageComponentDto>;
+    videoPlayer?: VideoPlayerDto;
+    initialTasks: Array<Task>;
+}
+declare const PageDto: {
+    createDummy: (id: number) => PageDto;
+};
+
+type PageQueRules = Rule<RuleActionPageQue, never>;
+interface PageSequenceDto {
+    readonly id: string;
+    readonly rules: Array<PageQueRules>;
+    readonly pages: Array<PageDto>;
+}
+interface SchemaDto {
+    readonly id: string;
+    readonly baseHeight: number;
+    readonly baseWidth: number;
+    readonly backgroundColor: string;
+    readonly pages: Array<PageDto>;
+    readonly rules: Array<PageQueRules>;
+    readonly pageSequences?: Array<PageSequenceDto>;
+    readonly predefinedFacts?: ReadonlyArray<Fact>;
+}
+
+interface EngineLogger {
+    info(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+interface ISchemaEngine {
+    onProgress(handler: (result: SchemaResult) => void): void;
+    onFatalError(handler: (error: {
+        message: string;
+    }) => void): void;
+    setLogger(logger: EngineLogger): void;
+}
+declare class SchemaEngine implements ISchemaEngine {
+    private readonly height;
+    private readonly width;
+    private readonly schema;
+    private readonly TAG;
+    private readonly scale;
+    private readonly hostElement;
+    private readonly taskManager;
+    private logger;
+    private readonly uiLayer;
+    private readonly mediaLayer;
+    private player;
+    private currentPage;
+    private readonly tickerRef;
+    constructor(hostEl: HTMLDivElement, height: number, width: number, schema: SchemaDto);
+    private handlePageCompleted;
+    private styleSelf;
+    private nextPage;
+    destroy(): void;
+    private _onProgress;
+    onProgress(handler: (result: SchemaResult) => void): void;
+    private _onFatalError;
+    onFatalError(handler: (error: {
+        message: string;
+    }) => void): void;
+    setLogger(logger: EngineLogger): void;
+}
+
+interface SolveResult<S, F> {
+    matching: ReadonlyArray<Match<S, F>>;
+    errors: ReadonlyArray<RuleEngineError>;
+}
+interface Match<S, F> {
+    readonly matchingRuleId: string;
+    readonly ruleDescription: string;
+    readonly actionList: ReadonlyArray<S> | ReadonlyArray<F>;
+}
+interface RuleEngineError {
+    readonly kind?: string;
+    readonly message: string;
+}
+declare class RuleEngine<S, F> {
+    constructor();
+    solveAll(rules: Rule<S, F>[], facts: Fact[]): SolveResult<S, F>;
+    solve(rule: Rule<S, F>, facts: Fact[]): boolean;
+}
+
+declare namespace DUtil {
+    const randomString: (length: number) => string;
+    const randomObjectId: () => string;
+    const deleteProp: <Obj, Key extends keyof Obj>(obj: Obj, key: Key) => Omit<Obj, Key>;
+    const isInRange: (min: number, max: number) => (value: number) => boolean;
+    const isInfinity: (number: number) => boolean;
+    type NonEmptyArray<T> = [T, ...T[]];
+    const isNonEmptyArray: <T>(array: T[]) => array is NonEmptyArray<T>;
+    const neverCheck: (args: never) => void;
+    const isString: (str: unknown) => str is string;
+    const hasKey: <T extends string>(obj: unknown, key: T) => obj is Record<T, unknown>;
+    const isRecord: (obj: unknown) => obj is Record<string, unknown>;
+    const isBool: (obj?: boolean) => obj is boolean;
+    const isTrue: (bool?: boolean) => bool is true;
+    const isFalse: (bool?: boolean) => bool is false;
+    const isDefined: (obj: unknown) => boolean;
+    const hasKind: (obj: unknown) => obj is {
+        readonly kind: string;
+    };
+    const hasValue: (obj: unknown) => obj is {
+        value: unknown;
+    };
+    const isNumber: (value?: number) => value is number;
+    const maxFn: (upperLimit: number) => (value: number) => number;
+    const minFn: (lowerLimit: number) => (value: number) => number;
+}
+
+export { ButtonClickAction, Condition, DCss, DDiv, type DDivDto, DElement, type DElementBaseDto, type DElementDto, DImg, type DImgDto, DStyle, DText, type DTextDto, DUtil, type DelayTask, type EngineLogger, Fact, type ISchemaEngine, type Match, MqEvent, type MqEventEngineStart, type MqEventPageEnter, type MqEventPageLeave, type MqEventUserClicked, type PStyle, PageComponent, type PageComponentDto, PageDto, type PageQueRules, type PageSequenceDto, type PlayAudioTask, type PlayVideoTask, Rule, type RuleActionPageQue, RuleEngine, type RuleEngineError, type SchemaDto, SchemaEngine, type SchemaResult, type SolveResult, Task };