@visactor/vchart/esm/compile/stage-app.js

charts lib based @visactor/VGrammar

import { acquireSharedVRenderApp } from "@visactor/vrender/entries/shared";

import { RenderModeEnum } from "../typings/spec/common";

export const getVRenderAppEnv = mode => {
    switch (mode) {
      case RenderModeEnum.node:
      case RenderModeEnum.worker:
        return "node";

      case RenderModeEnum.miniApp:
      case RenderModeEnum["desktop-miniApp"]:
        return "feishu";

      case RenderModeEnum.wx:
        return "wx";

      case RenderModeEnum.tt:
        return "tt";

      case RenderModeEnum.harmony:
        return "harmony";

      case RenderModeEnum.lynx:
        return "lynx";

      default:
        return "browser";
    }
};

const isObjectLike = value => null != value && ("object" == typeof value || "function" == typeof value), APP_ENV_PARAM_KEYS_BY_ENV = {
    lynx: [ "pixelRatio", "lynx", "runtime", "canvasFactory" ],
    harmony: [ "pixelRatio", "harmony", "runtime", "canvasFactory" ]
};

export const getVRenderAppEnvParams = (mode, modeParams) => {
    const env = getVRenderAppEnv(mode), appEnvParamKeys = APP_ENV_PARAM_KEYS_BY_ENV[env];
    if (!appEnvParamKeys) return modeParams;
    if (null == (value = modeParams) || "object" != typeof value && "function" != typeof value) return;
    var value;
    const envParams = {};
    return appEnvParamKeys.forEach((key => {
        void 0 !== modeParams[key] && (envParams[key] = modeParams[key]);
    })), Object.keys(envParams).length ? envParams : void 0;
};

const isIApp = value => !!value && "function" == typeof value.createStage, normalizeResolveOptions = (appOrOptions, mode) => {
    return !appOrOptions || (value = appOrOptions) && "function" == typeof value.createStage ? {
        app: appOrOptions,
        mode: mode
    } : appOrOptions;
    var value;
}, acquireDefaultVRenderApp = (env, envParams) => {
    const handle = acquireSharedVRenderApp(Object.assign({
        env: env
    }, void 0 === envParams ? {} : {
        envParams: envParams
    }));
    return {
        app: handle.app,
        releaseAppRef: () => handle.release()
    };
};

export const resolveVRenderApp = (appOrOptions, mode) => {
    const options = normalizeResolveOptions(appOrOptions, mode);
    if (options.app) return {
        app: options.app
    };
    const env = getVRenderAppEnv(options.mode), envParams = getVRenderAppEnvParams(options.mode, options.modeParams);
    return acquireDefaultVRenderApp(env, envParams);
};

export const createStageFromApp = (app, params) => app.createStage(params)
//# sourceMappingURL=stage-app.js.map
;