eli-video-interview 1.1.0

package/esm/modules/ai-report/interface.d.ts

@@ -0,0 +1,114 @@
+import { ScoreRankInterval, ScoreRankIntervals } from './components/RankingRange/interface';
+export interface AiModel {
+    token: string;
+    name: string;
+}
+export interface Question {
+    token: string;
+    name: string;
+    desc: string;
+    duration: number;
+    type: number;
+}
+export interface AnalysisResult {
+    text: string;
+    answer: string;
+    colorBlindAnswer: string;
+    img: string;
+    pass?: boolean;
+    letter: string;
+    pronAccuracy?: any;
+    pronCompletion?: any;
+    pronFluency?: any;
+    suggestedScore?: any;
+    words?: any;
+    score1?: number;
+    score2?: number;
+}
+export interface Answer {
+    videoUrl: string;
+    analysisResult: AnalysisResult;
+}
+export interface Ability {
+    originScore: number;
+    finalScore: number;
+    name: string;
+    type: number;
+    weight: number | string;
+}
+export interface ScoreInfo {
+    weight: number | string;
+    originScore: number;
+    finalScore: number;
+    score: number;
+    abilities: Ability[];
+}
+export interface AiEvaluation {
+    assessmentPoint: string[];
+    balancePoint: string[];
+    increasePoint: any[];
+    decreasePoint: any[];
+}
+export interface AiInterviewReportStep {
+    token: string;
+    status: number;
+    question: Question;
+    answer: Answer;
+    scoreInfo: ScoreInfo;
+    aiEvaluation: AiEvaluation;
+}
+export interface FaceAnalysis {
+    age: number;
+    beauty: number;
+}
+export interface AiInterviewReportList {
+    orderToken: string;
+    aiModel: AiModel;
+    faceUrl: string;
+    faceAnalysis: FaceAnalysis;
+    score: number;
+    status: number;
+    completedStatus: number;
+    createTime: number;
+    startTime: number;
+    completeTime: number;
+    steps: AiInterviewReportStep[];
+}
+export interface AiInterviewReportData {
+    list: AiInterviewReportList[];
+}
+export interface AiInterviewReportRes {
+    data: AiInterviewReportData;
+}
+export interface ScoreManualUpdateState {
+    flowStepToken: string;
+    type: 1 | 2;
+    aiAbilityChangeType?: number;
+    score: number;
+}
+export interface AiReportLoadedValues extends AiInterviewReportList {
+    pageStepIndexes: number[];
+}
+export interface InterviewCheat {
+    isCheat: boolean;
+    info: string;
+}
+export interface AiReportProps {
+    token: string;
+    scoreRankIntervals?: ScoreRankInterval[];
+    disabledScore?: boolean;
+    reminderSent?: boolean;
+    operableButtons?: Array<'export' | 'refresh' | 'scoreRank' | 'abilities' | 'sendReminder'>;
+    stepToken?: string;
+    interviewCheat?: InterviewCheat;
+    onLoad?: (values: AiReportLoadedValues) => void;
+    onExportReportClick?: () => void;
+    onScoreChange?: (scoreState?: ScoreManualUpdateState) => void;
+    onStepChange?: (stepToken: string) => void;
+    onSendReminderClick?: () => void;
+    onScoreRankIntervalsChange?: (scoreRankIntervals?: ScoreRankIntervals[]) => void;
+    onScoreRankIntervalsSubmit?: (scoreRankIntervals?: ScoreRankIntervals[]) => Promise<any>;
+}
+export interface AiReportRef {
+    handleRefresh: () => void;
+}

package/esm/modules/ai-report/interface.js

@@ -0,0 +1 @@
+export {};

package/esm/modules/ai-report/useAiReport.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { AiReportProps, AiReportRef } from './interface';
+export declare const useAiReport: (props: AiReportProps) => {
+    handleRefresh?: (() => void) | undefined;
+    token: string;
+    scoreRankIntervals?: import("./components/RankingRange/interface").ScoreRankInterval[] | undefined;
+    disabledScore?: boolean | undefined;
+    reminderSent?: boolean | undefined;
+    operableButtons?: ("export" | "refresh" | "scoreRank" | "abilities" | "sendReminder")[] | undefined;
+    stepToken?: string | undefined;
+    interviewCheat?: import("./interface").InterviewCheat | undefined;
+    onLoad?: ((values: import("./interface").AiReportLoadedValues) => void) | undefined;
+    onExportReportClick?: (() => void) | undefined;
+    onScoreChange?: ((scoreState?: import("./interface").ScoreManualUpdateState | undefined) => void) | undefined;
+    onStepChange?: ((stepToken: string) => void) | undefined;
+    onSendReminderClick?: (() => void) | undefined;
+    onScoreRankIntervalsChange?: ((scoreRankIntervals?: import("./components/RankingRange/interface").ScoreRankIntervals[] | undefined) => void) | undefined;
+    onScoreRankIntervalsSubmit?: ((scoreRankIntervals?: import("./components/RankingRange/interface").ScoreRankIntervals[] | undefined) => Promise<any>) | undefined;
+    ref: import("react").MutableRefObject<AiReportRef | undefined>;
+};

package/esm/modules/ai-report/useAiReport.js

@@ -0,0 +1,16 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useRef } from 'react';
+export var useAiReport = function (props) {
+    var ref = useRef();
+    return __assign(__assign({ ref: ref }, props), ref === null || ref === void 0 ? void 0 : ref.current);
+};

package/esm/services/ai-question.d.ts

@@ -0,0 +1,13 @@
+export declare const PostCommonUpload: <R>(data: FormData) => import("axios").AxiosPromise<R>;
+export declare const PostAiModelQuestions: <R>() => import("axios").AxiosPromise<R>;
+export declare const PostAiModels: <R>() => import("axios").AxiosPromise<R>;
+export declare const PostAiModelDetails: <R>(token: string) => import("axios").AxiosPromise<R>;
+export declare const PostAiAbilities: <R>() => import("axios").AxiosPromise<R>;
+export declare const PostAiModelUpsert: <R>(data: any) => import("axios").AxiosPromise<R>;
+export declare const GetHistoryPatterns: <R>() => import("axios").AxiosPromise<R>;
+interface PostAiInterviewData {
+    aiModelToken: string;
+    orderTokens: string[];
+}
+export declare const PostAiInterview: <R>(data: PostAiInterviewData) => import("axios").AxiosPromise<R>;
+export {};

package/esm/services/ai-question.js

@@ -0,0 +1,17 @@
+import { GET, POST } from "../utils/request";
+// 公共上传
+export var PostCommonUpload = function (data) { return POST({ url: '/common/upload', data: data }); };
+// 题库模版列表
+export var PostAiModelQuestions = function () { return POST({ url: '/standard/b/aiModel/questions' }); };
+// AI模型列表
+export var PostAiModels = function () { return POST({ url: '/standard/b/aiModels' }); };
+// AI模型详情
+export var PostAiModelDetails = function (token) { return POST({ url: "/standard/b/aiModel/".concat(token) }); };
+// AI维度列表
+export var PostAiAbilities = function () { return POST({ url: "/standard/b/aiAbilities" }); };
+// 创建或修改AI模型
+export var PostAiModelUpsert = function (data) { return POST({ url: '/standard/b/aiModel/upsert', data: data }); };
+// 已有岗位模型
+export var GetHistoryPatterns = function () { return GET({ url: '/aiProcess/historyPatterns' }); };
+// 创建面试
+export var PostAiInterview = function (data) { return POST({ url: '/standard/b/aiInterview', data: data }); };

package/esm/services/ai-report.d.ts

@@ -0,0 +1,2 @@
+export declare const PostAiInterviewResult: <R>(orderTokens: string[]) => import("axios").AxiosPromise<R>;
+export declare const PostAiInterviewRefresh: <R>(orderID: string) => import("axios").AxiosPromise<R>;

package/esm/services/ai-report.js

@@ -0,0 +1,5 @@
+import { POST } from "../utils/request";
+// 查询面试结果
+export var PostAiInterviewResult = function (orderTokens) { return POST({ url: "/standard/b/aiInterview/result", data: { orderTokens: orderTokens } }); };
+// 刷新ai评分
+export var PostAiInterviewRefresh = function (orderID) { return POST({ url: "/standard/b/aiInterview/aiScore/refresh/single", data: { orderID: orderID } }); };

package/esm/store/ai-question/ai-analysis-store.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { QuestionParams } from '@/modules/ai-question/components/QuestionUpdate/interface';
+import { AiAbilityItem } from '@/modules/ai-question/components/AiAssessmentCriteria/interface';
+interface AnalysisStateParams extends Pick<QuestionParams, 'aiSwitch' | 'language'> {
+}
+export declare const useAiAnalysisStore: (depsFn?: import("hox/es/types").DepsFn<{
+    aiAbilities: AiAbilityItem[];
+    analysisState: AnalysisStateParams;
+    keyPointAnalysisError: number[];
+    updateState: (params: Partial<AnalysisStateParams>) => void;
+    updateAiAbilities: (data: AiAbilityItem[], inInit?: any) => void;
+    updateAiAbilitiesWeight: (value: string, index: number) => void;
+    removeAiAbilities: (index: number) => void;
+    setKeyPointAnalysisError: import("react").Dispatch<import("react").SetStateAction<number[]>>;
+}> | undefined) => {
+    aiAbilities: AiAbilityItem[];
+    analysisState: AnalysisStateParams;
+    keyPointAnalysisError: number[];
+    updateState: (params: Partial<AnalysisStateParams>) => void;
+    updateAiAbilities: (data: AiAbilityItem[], inInit?: any) => void;
+    updateAiAbilitiesWeight: (value: string, index: number) => void;
+    removeAiAbilities: (index: number) => void;
+    setKeyPointAnalysisError: import("react").Dispatch<import("react").SetStateAction<number[]>>;
+}, AiAnalysisStoreProvider: import("react").FC<{
+    children?: import("react").ReactNode;
+}> | import("react").NamedExoticComponent<{
+    children?: import("react").ReactNode;
+}>;
+export {};

package/esm/store/ai-question/ai-analysis-store.js

@@ -0,0 +1,132 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { useEffect, useState, useCallback } from 'react';
+import update from 'immutability-helper';
+import { createStore } from 'hox';
+import { useSetState } from 'ahooks';
+import { formatNumberDecimal, computeDecimalValue, uniqueId } from "../../utils/utils";
+import { useUpdateQuestionStore } from "./question-update-store";
+var defaultAnalysisState = { aiSwitch: 2, language: 1 };
+export var useAiAnalysisStore = (_a = createStore(function () {
+    var questionState = useUpdateQuestionStore(function (store) { return [store.questionState]; }).questionState;
+    var _a = useState([]), aiAbilities = _a[0], setAiAbilities = _a[1];
+    var _b = useSetState(defaultAnalysisState), analysisState = _b[0], setState = _b[1];
+    var _c = useState([]), keyPointAnalysisError = _c[0], setKeyPointAnalysisError = _c[1];
+    var updateState = function (params) { return setState(params); };
+    /**
+     * 权重值计算
+     * @param steps 模型数据
+     */
+    var computeWeight = useCallback(function (data, inInit) {
+        if (inInit === void 0) { inInit = false; }
+        var weightList = data.filter(function (_a) {
+            var isNotCompute = _a.isNotCompute;
+            return !isNotCompute;
+        }).map(function (_a) {
+            var weight = _a.weight;
+            return Math.floor(Number(weight));
+        });
+        var weightsLen = Array.from(new Set(weightList)).length;
+        var lastToken = data.length ? data[data.length - 1].token : '';
+        var beforeTotalWeight = data.map(function (_a, i) {
+            var weight = _a.weight;
+            return (i < data.length - 1 ? Number(weight) : 0);
+        }).reduce(function (pv, i) { return pv + i; }, 0);
+        var getWeight = function (_a) {
+            var token = _a.token, weight = _a.weight;
+            if (weightsLen <= 1 && !inInit) {
+                var dataLength = data.length;
+                var averageWeight = 100 / dataLength;
+                var disableWeight = 100 - Math.floor(averageWeight * (dataLength - 1) * 100) / 100;
+                return token === data[dataLength - 1].token ? computeDecimalValue(disableWeight.toString()) : computeDecimalValue(averageWeight.toString());
+            }
+            else {
+                return lastToken !== token ? weight : computeDecimalValue((100 - beforeTotalWeight).toString());
+            }
+        };
+        var $splice = data.map(function (item, i) {
+            return [
+                i,
+                1,
+                __assign(__assign({}, item), { isNotCompute: false, weight: getWeight(item) }),
+            ];
+        });
+        setAiAbilities(update(data, { $splice: $splice }));
+    }, []);
+    /**
+     * 更新AI分析维度
+     */
+    var updateAiAbilities = useCallback(function (data, inInit) {
+        if (inInit === void 0) { inInit = false; }
+        console.log(data);
+        data.forEach(function (item) {
+            if (item.isNotCompute === undefined) {
+                item.isNotCompute = true;
+            }
+            if (!item.extra) {
+                if (item.type === 6) {
+                    item.extra = JSON.stringify([{ words: '', score: '0', color: 'rgb(249, 222, 148)', id: uniqueId() }]);
+                }
+                if (item.type === 8) {
+                    item.extra = JSON.stringify({ expect: 'positive' });
+                }
+            }
+        });
+        computeWeight(data, inInit);
+    }, [computeWeight]);
+    /**
+     * 更新AI分析维度权重
+     */
+    var updateAiAbilitiesWeight = useCallback(function (value, index) {
+        var _a;
+        var formatValue = formatNumberDecimal(value);
+        var curOriginalWeight = Number(aiAbilities[index].weight);
+        var disabledWeight = Number(aiAbilities[aiAbilities.length - 1].weight);
+        var maxInputValue = computeDecimalValue((curOriginalWeight + disabledWeight).toString());
+        if (Number(formatValue) <= maxInputValue) {
+            var newAiAbilities = update(aiAbilities, (_a = {}, _a[index] = { weight: { $set: formatValue } }, _a));
+            computeWeight(newAiAbilities);
+        }
+    }, [aiAbilities, computeWeight]);
+    /**
+     * 删除AI分析维度
+     */
+    var removeAiAbilities = useCallback(function (index) {
+        var newAiAbilities = update(aiAbilities, { $splice: [[index, 1]] });
+        if (newAiAbilities.length) {
+            computeWeight(newAiAbilities);
+        }
+        else {
+            setAiAbilities(newAiAbilities);
+        }
+    }, [aiAbilities, computeWeight]);
+    useEffect(function () {
+        if (!questionState.open) {
+            setTimeout(function () {
+                setAiAbilities([]);
+                setState(defaultAnalysisState);
+                setKeyPointAnalysisError([]);
+            });
+        }
+    }, [questionState.open, setState]);
+    return {
+        aiAbilities: aiAbilities,
+        analysisState: analysisState,
+        keyPointAnalysisError: keyPointAnalysisError,
+        updateState: updateState,
+        updateAiAbilities: updateAiAbilities,
+        updateAiAbilitiesWeight: updateAiAbilitiesWeight,
+        removeAiAbilities: removeAiAbilities,
+        setKeyPointAnalysisError: setKeyPointAnalysisError,
+    };
+}), _a[0]), AiAnalysisStoreProvider = _a[1];

package/esm/store/ai-question/boot-video-store.d.ts

@@ -0,0 +1,17 @@
+import { Media } from '@/modules/ai-question/interface';
+export declare const useBootVideoStore: (depsFn?: import("hox/es/types").DepsFn<{
+    updateBootVideo: (params: Media) => void;
+    mediaUrl?: string | undefined;
+    thumbUrl?: string | undefined;
+    appliedAllPosition?: boolean | undefined;
+}> | undefined) => {
+    updateBootVideo: (params: Media) => void;
+    mediaUrl?: string | undefined;
+    thumbUrl?: string | undefined;
+    appliedAllPosition?: boolean | undefined;
+}, getBootVideoStore: () => {
+    updateBootVideo: (params: Media) => void;
+    mediaUrl?: string | undefined;
+    thumbUrl?: string | undefined;
+    appliedAllPosition?: boolean | undefined;
+} | undefined;

package/esm/store/ai-question/boot-video-store.js

@@ -0,0 +1,21 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { useState } from 'react';
+import { createGlobalStore } from 'hox';
+export var useBootVideoStore = (_a = createGlobalStore(function () {
+    var _a = useState({ mediaUrl: '', thumbUrl: '', appliedAllPosition: false }), state = _a[0], setState = _a[1];
+    var updateBootVideo = function (params) {
+        setState(__assign(__assign({}, state), params));
+    };
+    return __assign(__assign({}, state), { updateBootVideo: updateBootVideo });
+}), _a[0]), getBootVideoStore = _a[1];

package/esm/store/ai-question/global-store.d.ts

@@ -0,0 +1,32 @@
+import { AiQuestionProps } from '@/modules/ai-question/interface';
+export declare const useAiQuestionStore: (depsFn?: import("hox/es/types").DepsFn<{
+    updateState: import("ahooks/lib/useSetState").SetState<AiQuestionProps>;
+    token: string;
+    name?: string | undefined;
+    historyPatterns?: any[] | undefined;
+    mediaList?: {
+        url: string;
+        thumbUrl: string;
+    }[] | undefined;
+    onLoad?: ((steps: import("../../modules/ai-question/components/QuestionModel/interface").QuestionModelStep[] | undefined) => void) | undefined;
+}> | undefined) => {
+    updateState: import("ahooks/lib/useSetState").SetState<AiQuestionProps>;
+    token: string;
+    name?: string | undefined;
+    historyPatterns?: any[] | undefined;
+    mediaList?: {
+        url: string;
+        thumbUrl: string;
+    }[] | undefined;
+    onLoad?: ((steps: import("../../modules/ai-question/components/QuestionModel/interface").QuestionModelStep[] | undefined) => void) | undefined;
+}, getAiQuestionStore: () => {
+    updateState: import("ahooks/lib/useSetState").SetState<AiQuestionProps>;
+    token: string;
+    name?: string | undefined;
+    historyPatterns?: any[] | undefined;
+    mediaList?: {
+        url: string;
+        thumbUrl: string;
+    }[] | undefined;
+    onLoad?: ((steps: import("../../modules/ai-question/components/QuestionModel/interface").QuestionModelStep[] | undefined) => void) | undefined;
+} | undefined;

package/esm/store/ai-question/global-store.js

@@ -0,0 +1,23 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { useSetState } from 'ahooks';
+import { createGlobalStore } from 'hox';
+export var useAiQuestionStore = (_a = createGlobalStore(function () {
+    var _a = useSetState({
+        token: '',
+        name: '',
+        historyPatterns: [],
+        mediaList: [],
+    }), state = _a[0], updateState = _a[1];
+    return __assign(__assign({}, state), { updateState: updateState });
+}), _a[0]), getAiQuestionStore = _a[1];

package/esm/store/ai-question/question-model-store.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { QuestionModelData, QuestionModelStep } from '@/modules/ai-question/components/QuestionModel/interface';
+export declare const useQuestionModelStore: (depsFn?: import("hox/es/types").DepsFn<{
+    questionModelData: QuestionModelData | undefined;
+    addModel: (modelStep: QuestionModelStep | QuestionModelStep[]) => void;
+    editModel: (modelStep: QuestionModelStep, index: number) => void;
+    removeModel: (index: number) => void;
+    updateModel: import("react").Dispatch<import("react").SetStateAction<QuestionModelData | undefined>>;
+    updateModelWeight: (value: string, index: number) => void;
+}> | undefined) => {
+    questionModelData: QuestionModelData | undefined;
+    addModel: (modelStep: QuestionModelStep | QuestionModelStep[]) => void;
+    editModel: (modelStep: QuestionModelStep, index: number) => void;
+    removeModel: (index: number) => void;
+    updateModel: import("react").Dispatch<import("react").SetStateAction<QuestionModelData | undefined>>;
+    updateModelWeight: (value: string, index: number) => void;
+}, getQuestionModelStore: () => {
+    questionModelData: QuestionModelData | undefined;
+    addModel: (modelStep: QuestionModelStep | QuestionModelStep[]) => void;
+    editModel: (modelStep: QuestionModelStep, index: number) => void;
+    removeModel: (index: number) => void;
+    updateModel: import("react").Dispatch<import("react").SetStateAction<QuestionModelData | undefined>>;
+    updateModelWeight: (value: string, index: number) => void;
+} | undefined;

package/esm/store/ai-question/question-model-store.js

@@ -0,0 +1,130 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var _a;
+import { useState, useCallback } from 'react';
+import { createGlobalStore } from 'hox';
+import update from 'immutability-helper';
+import { IS_AI_ANALYSIS } from "../../constants/ai-question";
+import { formatNumberDecimal, computeDecimalValue, uniqueId, arrayUnique } from "../../utils/utils";
+export var useQuestionModelStore = (_a = createGlobalStore(function () {
+    var _a = useState(), questionModelData = _a[0], updateModel = _a[1];
+    var _b = (questionModelData || {}).steps, steps = _b === void 0 ? [] : _b;
+    /**
+     * 权重值计算
+     * @param steps 模型数据
+     */
+    var computeWeight = useCallback(function (steps) {
+        var aiTypeList = steps.filter(function (step) { return IS_AI_ANALYSIS(step); }); // AI评分题
+        var uniqueAiTypeList = arrayUnique(aiTypeList, 'token'); // 去除重复AI评分题
+        var uniqueAiTypeListLength = uniqueAiTypeList.length;
+        var weightList = aiTypeList.filter(function (_a) {
+            var isNotCompute = _a.isNotCompute;
+            return !isNotCompute;
+        }).map(function (_a) {
+            var weight = _a.weight;
+            return Math.floor(Number(weight));
+        });
+        var weightsLen = Array.from(new Set(weightList)).length; // 权重值分组数量
+        var lastAiTestToken = aiTypeList.length ? aiTypeList[aiTypeList.length - 1].token : '';
+        var beforeTotalWeight = aiTypeList
+            .map(function (_a) {
+            var token = _a.token, weight = _a.weight;
+            return (lastAiTestToken !== token ? Number(weight) : 0);
+        })
+            .reduce(function (pv, i) { return pv + i; }, 0);
+        var totalDuration = 0;
+        var getWeight = function (_a) {
+            var token = _a.token, weight = _a.weight;
+            if (weightsLen <= 1) {
+                var averageWeight = 100 / uniqueAiTypeListLength;
+                var disableWeight = 100 - Math.floor(averageWeight * (uniqueAiTypeListLength - 1) * 100) / 100;
+                return token === uniqueAiTypeList[uniqueAiTypeListLength - 1].token
+                    ? computeDecimalValue(disableWeight.toString())
+                    : computeDecimalValue(averageWeight.toString());
+            }
+            else {
+                return lastAiTestToken !== token ? weight : computeDecimalValue((100 - beforeTotalWeight).toString());
+            }
+        };
+        var $splice = steps.map(function (step, i) {
+            totalDuration += step.duration;
+            delete step.isNotCompute;
+            return [
+                i,
+                1,
+                __assign(__assign({}, step), { weight: IS_AI_ANALYSIS(step) ? getWeight(step) : 0 }),
+            ];
+        });
+        updateModel(__assign(__assign({}, questionModelData), { duration: totalDuration, steps: update(steps, { $splice: $splice }) }));
+    }, [questionModelData]);
+    /**
+     * 更新模型数据权重值
+     * @param value 权重值
+     * @param index 下标
+     */
+    var updateModelWeight = useCallback(function (value, index) {
+        var _a;
+        var formatValue = formatNumberDecimal(value);
+        var curOriginalWeight = Number(steps[index].weight);
+        var aiTypeList = steps.filter(function (step) { return IS_AI_ANALYSIS(step); });
+        var disabledStep = aiTypeList.length ? aiTypeList[aiTypeList.length - 1] : undefined;
+        var maxInputValue = computeDecimalValue((curOriginalWeight + ((disabledStep === null || disabledStep === void 0 ? void 0 : disabledStep.weight) ? Number(disabledStep === null || disabledStep === void 0 ? void 0 : disabledStep.weight) : 0)).toString());
+        if (Number(formatValue) <= maxInputValue) {
+            var newSteps = update(steps, (_a = {}, _a[index] = { weight: { $set: formatValue } }, _a));
+            computeWeight(newSteps);
+        }
+    }, [steps, computeWeight]);
+    /**
+     * 新增模型数据
+     * @param modelStep 新增数据项
+     */
+    var addModel = useCallback(function (modelStep) {
+        var stepArr = Array.isArray(modelStep)
+            ? modelStep.map(function (item) { return (__assign(__assign({}, item), { isNotCompute: true, uniqueId: uniqueId() })); })
+            : [__assign(__assign({}, modelStep), { isNotCompute: true, uniqueId: uniqueId() })];
+        var newSteps = update(steps, { $push: stepArr });
+        computeWeight(newSteps);
+    }, [computeWeight, steps]);
+    /**
+     * 编辑模型数据
+     * @param modelStep 编辑数据项
+     * @param index 下标
+     */
+    var editModel = useCallback(function (modelStep, index) {
+        var aiTypeList = steps.filter(function (step) { return IS_AI_ANALYSIS(step); });
+        var newSteps = update(steps, {
+            $splice: [[index, 1, __assign(__assign(__assign({}, steps[index]), modelStep), { weight: aiTypeList.length ? modelStep.weight : 100 })]],
+        });
+        computeWeight(newSteps);
+    }, [computeWeight, steps]);
+    /**
+     * 删除模型数据
+     * @param index 下标
+     */
+    var removeModel = useCallback(function (index) {
+        var newSteps = update(steps, { $splice: [[index, 1]] });
+        if (newSteps.length) {
+            computeWeight(newSteps);
+        }
+        else {
+            updateModel(__assign(__assign({}, questionModelData), { duration: 0, steps: newSteps }));
+        }
+    }, [computeWeight, questionModelData, steps]);
+    return {
+        questionModelData: questionModelData,
+        addModel: addModel,
+        editModel: editModel,
+        removeModel: removeModel,
+        updateModel: updateModel,
+        updateModelWeight: updateModelWeight,
+    };
+}), _a[0]), getQuestionModelStore = _a[1];

package/esm/store/ai-question/question-preview-store.d.ts

@@ -0,0 +1,14 @@
+import { AiEvaluationList } from '@@/src/modules/ai-question/components/QuestionTemplate/interface';
+export declare const useQuestionPreviewStore: (depsFn?: import("hox/es/types").DepsFn<{
+    visible: boolean;
+    previewItem: AiEvaluationList | undefined;
+    updatePreview: (visible: boolean, item?: AiEvaluationList) => void;
+}> | undefined) => {
+    visible: boolean;
+    previewItem: AiEvaluationList | undefined;
+    updatePreview: (visible: boolean, item?: AiEvaluationList) => void;
+}, getQuestionPreviewStore: () => {
+    visible: boolean;
+    previewItem: AiEvaluationList | undefined;
+    updatePreview: (visible: boolean, item?: AiEvaluationList) => void;
+} | undefined;

package/esm/store/ai-question/question-preview-store.js

@@ -0,0 +1,21 @@
+var _a;
+import { useState, useCallback } from 'react';
+import { createGlobalStore } from 'hox';
+export var useQuestionPreviewStore = (_a = createGlobalStore(function () {
+    var _a = useState(false), visible = _a[0], setVisible = _a[1];
+    var _b = useState(), previewItem = _b[0], setPreviewItem = _b[1];
+    /**
+     * 更新预览数据
+     * @param visible 是否展示
+     * @param item 展示数据
+     */
+    var updatePreview = useCallback(function (visible, item) {
+        setVisible(visible);
+        setPreviewItem(item);
+    }, []);
+    return {
+        visible: visible,
+        previewItem: previewItem,
+        updatePreview: updatePreview,
+    };
+}), _a[0]), getQuestionPreviewStore = _a[1];