@pisell/materials 3.0.62 → 6.0.2

package/lib/components/dataSourceComponents/hooks/useDataSource.js

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/hooks/useDataSource.ts
+var useDataSource_exports = {};
+__export(useDataSource_exports, {
+  default: () => useDataSource_default
+});
+module.exports = __toCommonJS(useDataSource_exports);
+var import_react = require("react");
+var import_DataSourceContext = __toESM(require("../provider/dataSource/DataSourceContext"));
+var useDataSource = () => {
+  const config = (0, import_react.useContext)(import_DataSourceContext.default);
+  return config;
+};
+var useDataSource_default = useDataSource;

package/lib/components/dataSourceComponents/hooks/useParseActionsVariable.d.ts

@@ -0,0 +1,6 @@
+import { Collection } from '../dataSourceForm/serve';
+declare type Actions = Collection['actions'];
+declare const useParseActionsVariable: () => {
+    parseActions: (actions: Actions, localVariables: Record<string, any>) => Record<string, any>;
+};
+export default useParseActionsVariable;

package/lib/components/dataSourceComponents/hooks/useParseActionsVariable.js

@@ -0,0 +1,73 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/hooks/useParseActionsVariable.ts
+var useParseActionsVariable_exports = {};
+__export(useParseActionsVariable_exports, {
+  default: () => useParseActionsVariable_default
+});
+module.exports = __toCommonJS(useParseActionsVariable_exports);
+var import_ahooks = require("ahooks");
+var import_useVariables = __toESM(require("./useVariables"));
+var useParseActionsVariable = () => {
+  const { parseVariable } = (0, import_useVariables.default)();
+  const parseKeyValuePairs = (0, import_ahooks.useMemoizedFn)(
+    (pairs, localVariables) => pairs == null ? void 0 : pairs.map(({ name, value }) => ({
+      name,
+      value: parseVariable == null ? void 0 : parseVariable(value, localVariables)
+    }))
+  );
+  const parseActionsItem = (item, localVariables) => {
+    const { params, headers, body, path } = item;
+    const parsedBody = !body ? body : Object.entries(body).reduce((acc, [key, value]) => {
+      acc[key] = parseVariable == null ? void 0 : parseVariable(value, localVariables);
+      return acc;
+    }, {});
+    return {
+      ...item,
+      parsedPath: parseVariable == null ? void 0 : parseVariable(path, localVariables),
+      params: parseKeyValuePairs(params, localVariables),
+      headers: parseKeyValuePairs(headers, localVariables),
+      body: parsedBody
+    };
+  };
+  const parseActions = (0, import_ahooks.useMemoizedFn)(
+    (actions, localVariables) => {
+      if (!actions)
+        return actions;
+      return Object.entries(actions).reduce((acc, [key, value]) => {
+        acc[key] = parseActionsItem(value, localVariables);
+        return acc;
+      }, {});
+    }
+  );
+  return {
+    parseActions
+  };
+};
+var useParseActionsVariable_default = useParseActionsVariable;

package/lib/components/dataSourceComponents/hooks/useValueMap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 将 options 转换为 valueMap
+ * 使用在 ReadPretty Select Radio Checkbox 组件中
+ * @param options
+ * @returns
+ */
+declare const useValueMap: (options: any[]) => any;
+export default useValueMap;

package/lib/components/dataSourceComponents/hooks/useValueMap.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/hooks/useValueMap.ts
+var useValueMap_exports = {};
+__export(useValueMap_exports, {
+  default: () => useValueMap_default
+});
+module.exports = __toCommonJS(useValueMap_exports);
+var import_react = require("react");
+var import_utils = require("@pisell/utils");
+var useValueMap = (options) => {
+  return (0, import_react.useMemo)(() => {
+    return (options == null ? void 0 : options.reduce((acc, item) => {
+      const itemValue = item.value;
+      const itemLabel = item.label;
+      if ((0, import_utils.isString)(itemValue) && (0, import_utils.isString)(itemLabel)) {
+        acc[itemValue] = itemLabel;
+      }
+      return acc;
+    }, {})) || {};
+  }, [options]);
+};
+var useValueMap_default = useValueMap;

package/lib/components/dataSourceComponents/hooks/useVariables.d.ts

@@ -0,0 +1,2 @@
+declare const useVariables: () => import("../provider/variables/VariablesContext").VariablesContextType;
+export default useVariables;

package/lib/components/dataSourceComponents/hooks/useVariables.js

@@ -0,0 +1,40 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/hooks/useVariables.ts
+var useVariables_exports = {};
+__export(useVariables_exports, {
+  default: () => useVariables_default
+});
+module.exports = __toCommonJS(useVariables_exports);
+var import_react = require("react");
+var import_VariablesContext = __toESM(require("../provider/variables/VariablesContext"));
+var useVariables = () => {
+  return (0, import_react.useContext)(import_VariablesContext.default);
+};
+var useVariables_default = useVariables;

package/lib/components/dataSourceComponents/provider/actions/ActionsContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface ActionsContextType {
+    [key: string]: any;
+}
+declare const ActionsContext: import("react").Context<ActionsContextType>;
+export default ActionsContext;

package/lib/components/dataSourceComponents/provider/actions/ActionsContext.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/provider/actions/ActionsContext.ts
+var ActionsContext_exports = {};
+__export(ActionsContext_exports, {
+  default: () => ActionsContext_default
+});
+module.exports = __toCommonJS(ActionsContext_exports);
+var import_react = require("react");
+var ActionsContext = (0, import_react.createContext)({});
+var ActionsContext_default = ActionsContext;

package/lib/components/dataSourceComponents/provider/actions/ActionsProvider.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ActionsContextType } from './ActionsContext';
+/**
+ * 自定义请求的provider
+ * @param props
+ * @constructor
+ */
+declare const ActionsProvider: React.FC<ActionsContextType>;
+export default ActionsProvider;

package/lib/components/dataSourceComponents/provider/actions/ActionsProvider.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/provider/actions/ActionsProvider.tsx
+var ActionsProvider_exports = {};
+__export(ActionsProvider_exports, {
+  default: () => ActionsProvider_default
+});
+module.exports = __toCommonJS(ActionsProvider_exports);
+var import_react = __toESM(require("react"));
+var import_ActionsContext = __toESM(require("./ActionsContext"));
+var ActionsProvider = (props) => {
+  const { children, ...rest } = props;
+  const value = import_react.default.useMemo(() => {
+    return {
+      ...rest
+    };
+  }, [rest]);
+  return /* @__PURE__ */ import_react.default.createElement(import_ActionsContext.default.Provider, { value }, children);
+};
+var ActionsProvider_default = ActionsProvider;

package/lib/components/dataSourceComponents/provider/dataSource/DataSourceContext.d.ts

@@ -0,0 +1,104 @@
+/// <reference types="react" />
+import { Result } from 'ahooks/es/useRequest/src/types';
+import { ActionsItem } from '../../dataSourceForm/serve';
+export interface Field {
+    name: string;
+    type: string;
+    allowNull: boolean;
+    primaryKey: boolean;
+    unique: boolean;
+    autoIncrement: boolean;
+    description?: (null | string)[];
+    possibleTypes?: string[];
+    rawType: string;
+    interface: string;
+    uiSchema: UiSchema;
+    key?: string;
+    collectionName?: string;
+    collectionKey?: any;
+    dataSourceKey?: string;
+    defaultValue?: any;
+}
+interface UiSchema {
+    type?: string;
+    'x-component': string;
+    'x-component-props'?: Xcomponentprops;
+    'x-validator'?: string;
+    title: string;
+    default?: any;
+    enum?: any[];
+}
+interface Xcomponentprops {
+    style?: Style;
+    autoSize?: AutoSize;
+    stringMode?: boolean;
+    step?: string;
+    dateFormat?: string;
+    showTime?: boolean;
+}
+interface AutoSize {
+    minRows: number;
+}
+interface Style {
+    width: string;
+}
+export declare type ActionTypes = 'list' | 'get' | 'update' | 'create' | 'destroy';
+export declare type DataSourceType = {
+    actions: {
+        get: ActionsItem;
+        update: ActionsItem;
+        create: ActionsItem;
+        delete: ActionsItem;
+        list: ActionsItem;
+    };
+    headerDataSource: string;
+    dataSourceKey: string;
+    filterTargetKey: string;
+    introspected: boolean;
+    isCustomApi: boolean;
+    key: string;
+    tableName: string;
+    logging: boolean;
+    name: string;
+    title: string;
+    titleField: string;
+    types: ActionTypes[];
+    fields: Field[];
+    options: {
+        apiType: string;
+        baseUrl: string;
+    };
+};
+export declare type DataSourceContextProps = {
+    dataSource: DataSourceType;
+    children?: React.ReactNode;
+    currentValue?: string;
+    actions?: {
+        list?: () => Promise<any>;
+        get?: () => Promise<any>;
+        update?: () => Promise<any>;
+        create?: () => Promise<any>;
+        destroy?: () => Promise<any>;
+    };
+    overrideData?: {
+        list?: any;
+        get?: any;
+    };
+    autoRun?: {
+        list?: boolean;
+        get?: boolean;
+    };
+    __id?: string;
+    __designMode?: string;
+};
+export interface DataSourceContextType {
+    dataSource?: DataSourceType;
+    list: Result<any, any>;
+    destroy: Result<any, any>;
+    get: Result<any, any>;
+    update: Result<any, any>;
+    create: Result<any, any>;
+    __designMode?: string;
+}
+export declare const DataSourceContext: import("react").Context<DataSourceContextType>;
+export default DataSourceContext;

package/lib/components/dataSourceComponents/provider/dataSource/DataSourceContext.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/provider/dataSource/DataSourceContext.ts
+var DataSourceContext_exports = {};
+__export(DataSourceContext_exports, {
+  DataSourceContext: () => DataSourceContext,
+  default: () => DataSourceContext_default
+});
+module.exports = __toCommonJS(DataSourceContext_exports);
+var import_react = require("react");
+var initialContext = {
+  dataSource: {},
+  list: {},
+  destroy: {},
+  get: {},
+  update: {},
+  create: {}
+};
+var DataSourceContext = (0, import_react.createContext)(initialContext);
+var DataSourceContext_default = DataSourceContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSourceContext
+});

package/lib/components/dataSourceComponents/provider/dataSource/DataSourceProvider.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { DataSourceContextProps } from './DataSourceContext';
+/**
+ * @title: DataSource Provider
+ * @description: 提供页面配置的数据源，支持外部传入Promise接口、自动调用配置和直接数据
+ */
+declare const DataSourceProvider: React.FC<DataSourceContextProps>;
+export default DataSourceProvider;

package/lib/components/dataSourceComponents/provider/dataSource/DataSourceProvider.js

@@ -0,0 +1,108 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/provider/dataSource/DataSourceProvider.tsx
+var DataSourceProvider_exports = {};
+__export(DataSourceProvider_exports, {
+  default: () => DataSourceProvider_default
+});
+module.exports = __toCommonJS(DataSourceProvider_exports);
+var import_react = __toESM(require("react"));
+var import_ahooks = require("ahooks");
+var import_utils = require("@pisell/utils");
+var import_DataSourceContext = __toESM(require("./DataSourceContext"));
+var import_useActions = __toESM(require("../../hooks/useActions"));
+var import_useVariables = __toESM(require("../../hooks/useVariables"));
+var import_useSetRequest = __toESM(require("../../../../hooks/useSetRequest"));
+var DataSourceProvider = (props) => {
+  const {
+    children,
+    dataSource: propsDataSource,
+    currentValue,
+    actions: externalActions,
+    overrideData,
+    autoRun,
+    __designMode
+  } = props;
+  (0, import_useSetRequest.default)();
+  const { parseVariable } = (0, import_useVariables.default)();
+  const dataSource = (0, import_utils.isString)(propsDataSource) ? parseVariable == null ? void 0 : parseVariable(propsDataSource) : propsDataSource;
+  const standardActions = (0, import_useActions.default)({
+    dataSource,
+    currentValue,
+    __designMode
+  });
+  const list = (externalActions == null ? void 0 : externalActions.list) || standardActions.list;
+  const get = (externalActions == null ? void 0 : externalActions.get) || standardActions.get;
+  const update = (externalActions == null ? void 0 : externalActions.update) || standardActions.update;
+  const create = (externalActions == null ? void 0 : externalActions.create) || standardActions.create;
+  const destroy = (externalActions == null ? void 0 : externalActions.destroy) || standardActions.destroy;
+  const listResult = (0, import_ahooks.useRequest)(list, {
+    manual: (0, import_utils.isBoolean)(autoRun == null ? void 0 : autoRun.list) ? !(autoRun == null ? void 0 : autoRun.list) : true
+  });
+  const getResult = (0, import_ahooks.useRequest)(get, {
+    manual: (0, import_utils.isBoolean)(autoRun == null ? void 0 : autoRun.get) ? !(autoRun == null ? void 0 : autoRun.get) : true
+  });
+  const destroyResult = (0, import_ahooks.useRequest)(destroy, {
+    manual: true
+  });
+  const updateResult = (0, import_ahooks.useRequest)(update, {
+    manual: true
+  });
+  const createResult = (0, import_ahooks.useRequest)(create, {
+    manual: true
+  });
+  const value = (0, import_react.useMemo)(() => {
+    return {
+      __designMode,
+      dataSource,
+      list: {
+        ...listResult,
+        data: (overrideData == null ? void 0 : overrideData.list) || listResult.data
+      },
+      get: {
+        ...getResult,
+        data: (overrideData == null ? void 0 : overrideData.get) || getResult.data
+      },
+      destroy: destroyResult,
+      update: updateResult,
+      create: createResult
+    };
+  }, [
+    dataSource,
+    listResult,
+    destroyResult,
+    getResult,
+    updateResult,
+    createResult,
+    overrideData,
+    __designMode
+  ]);
+  return /* @__PURE__ */ import_react.default.createElement(import_DataSourceContext.default.Provider, { value }, children);
+};
+var DataSourceProvider_default = DataSourceProvider;

package/lib/components/dataSourceComponents/provider/variables/VariablesContext.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export interface VariablesContextType {
+    children?: React.ReactNode;
+    variables?: Record<string, any>;
+    registerVariable?: (value: Record<string, any>) => void;
+    parseVariable?: (str: string, localVariables?: Record<string, any>) => any;
+    registerValueVariable?: (componentId: string, value: Record<string, any>) => void;
+    registerFunctionVariable?: (componentId: string, value: Record<string, any>) => void;
+    subscribeVariables?: (listener: (allVariables: Record<string, any>, updateVariables: Record<string, any>) => void) => () => void;
+}
+export declare const VariablesContext: import("react").Context<VariablesContextType>;
+export default VariablesContext;

package/lib/components/dataSourceComponents/provider/variables/VariablesContext.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/dataSourceComponents/provider/variables/VariablesContext.ts
+var VariablesContext_exports = {};
+__export(VariablesContext_exports, {
+  VariablesContext: () => VariablesContext,
+  default: () => VariablesContext_default
+});
+module.exports = __toCommonJS(VariablesContext_exports);
+var import_react = require("react");
+var initialContext = {
+  variables: {},
+  registerVariable: () => {
+  },
+  registerValueVariable: () => {
+  },
+  registerFunctionVariable: () => {
+  },
+  parseVariable: () => {
+  }
+};
+var VariablesContext = (0, import_react.createContext)(initialContext);
+var VariablesContext_default = VariablesContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VariablesContext
+});

package/lib/components/dataSourceComponents/provider/variables/VariablesProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { VariablesContextType } from './VariablesContext';
+declare const VariablesProvider: React.FC<VariablesContextType>;
+export default VariablesProvider;