@nocobase/plugin-data-visualization 0.10.1-alpha.1

package/lib/client/hooks.d.ts

@@ -0,0 +1,312 @@
+import { ArrayField } from '@formily/core';
+import { ISchema } from '@formily/react';
+import { ChartRendererProps } from './renderer';
+export declare type FieldOption = {
+    value: string;
+    label: string;
+    key: string;
+    alias?: string;
+    name?: string;
+    type?: string;
+    interface?: string;
+    uiSchema?: ISchema;
+    target?: string;
+    targetFields?: FieldOption[];
+};
+export declare const useFields: (collection?: string) => {
+    key: any;
+    label: any;
+    value: any;
+    name?: any;
+    collectionName?: string;
+    sourceKey?: string;
+    uiSchema?: import("@formily/react").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/react").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/react").SchemaTypes;
+        enum?: import("@formily/react").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string; /**
+         * useFieldTypes
+         * Get field types for using transformers
+         * Only supported types will be displayed
+         * Some interfaces and types will be mapped to supported types
+         */
+        definitions?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/react").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/react").Stringify<any>;
+        patternProperties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/react").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/react").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>;
+    target?: string;
+}[];
+export declare const useFieldsWithAssociation: (collection?: string) => ({
+    label: any;
+    key: any;
+    value: any;
+    name?: any;
+    collectionName?: string;
+    sourceKey?: string;
+    uiSchema?: import("@formily/react").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/react").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/react").SchemaTypes;
+        enum?: import("@formily/react").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string; /**
+         * useFieldTypes
+         * Get field types for using transformers
+         * Only supported types will be displayed
+         * Some interfaces and types will be mapped to supported types
+         */
+        definitions?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/react").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/react").Stringify<any>;
+        patternProperties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/react").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/react").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>;
+    target?: string;
+} | {
+    label: any;
+    targetFields: {
+        key: string;
+        label: string;
+        value: string;
+        name?: any;
+        collectionName?: string;
+        sourceKey?: string;
+        uiSchema?: import("@formily/react").Stringify<{
+            [key: symbol]: any;
+            [key: `x-${string}`]: any;
+            [key: `x-${number}`]: any;
+            version?: string;
+            name?: import("@formily/react").SchemaKey;
+            title?: any;
+            description?: any;
+            default?: any;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            type?: import("@formily/react").SchemaTypes;
+            enum?: import("@formily/react").SchemaEnum<any>;
+            const?: any;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: number;
+            minimum?: number;
+            exclusiveMinimum?: number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string | RegExp;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string | boolean | string[];
+            format?: string;
+            $ref?: string;
+            $namespace?: string; /**
+             * useFieldTypes
+             * Get field types for using transformers
+             * Only supported types will be displayed
+             * Some interfaces and types will be mapped to supported types
+             */
+            definitions?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+            properties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+            items?: import("@formily/react").SchemaItems<any, any, any, any, any, any, any, any>;
+            additionalItems?: import("@formily/react").Stringify<any>;
+            patternProperties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+            additionalProperties?: import("@formily/react").Stringify<any>;
+            "x-value"?: any;
+            "x-index"?: number;
+            "x-pattern"?: any;
+            "x-display"?: any;
+            "x-validator"?: any;
+            "x-decorator"?: any;
+            "x-decorator-props"?: any;
+            "x-component"?: any;
+            "x-component-props"?: any;
+            "x-reactions"?: import("@formily/react").SchemaReactions<any>;
+            "x-content"?: any;
+            "x-data"?: any;
+            "x-visible"?: boolean;
+            "x-hidden"?: boolean;
+            "x-disabled"?: boolean;
+            "x-editable"?: boolean;
+            "x-read-only"?: boolean;
+            "x-read-pretty"?: boolean;
+            "x-compile-omitted"?: string[];
+        }>;
+        target?: string;
+    }[];
+    key: any;
+    value: any;
+    name?: any;
+    collectionName?: string;
+    sourceKey?: string;
+    uiSchema?: import("@formily/react").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@formily/react").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@formily/react").SchemaTypes;
+        enum?: import("@formily/react").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string | boolean | string[];
+        format?: string;
+        $ref?: string;
+        $namespace?: string; /**
+         * useFieldTypes
+         * Get field types for using transformers
+         * Only supported types will be displayed
+         * Some interfaces and types will be mapped to supported types
+         */
+        definitions?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@formily/react").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@formily/react").Stringify<any>;
+        patternProperties?: import("@formily/react").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@formily/react").Stringify<any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/react").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>;
+    target?: string;
+})[];
+export declare const useChartFields: (fields: FieldOption[]) => (field: any) => void;
+export declare const useFormatters: (fields: FieldOption[]) => (field: any) => void;
+export declare const useCollectionOptions: () => any;
+/**
+ * useFieldTypes
+ * Get field types for using transformers
+ * Only supported types will be displayed
+ * Some interfaces and types will be mapped to supported types
+ */
+export declare const useFieldTypes: (fields: FieldOption[]) => (field: any) => void;
+export declare const useTransformers: (field: any) => void;
+export declare const useFieldTransformer: (transform: ChartRendererProps['transform'], locale?: string) => {};
+export declare const useOrderFieldsOptions: (defaultOptions: any[], fields: FieldOption[]) => (field: any) => void;
+export declare const useOrderReaction: (defaultOptions: any[], fields: FieldOption[]) => (field: ArrayField) => void;

package/lib/client/hooks.js

@@ -0,0 +1,275 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTransformers = exports.useOrderReaction = exports.useOrderFieldsOptions = exports.useFormatters = exports.useFieldsWithAssociation = exports.useFields = exports.useFieldTypes = exports.useFieldTransformer = exports.useCollectionOptions = exports.useChartFields = void 0;
+function _react() {
+  const data = require("@formily/react");
+  _react = function _react() {
+    return data;
+  };
+  return data;
+}
+function _client() {
+  const data = require("@nocobase/client");
+  _client = function _client() {
+    return data;
+  };
+  return data;
+}
+function _react2() {
+  const data = require("react");
+  _react2 = function _react2() {
+    return data;
+  };
+  return data;
+}
+function _reactI18next() {
+  const data = require("react-i18next");
+  _reactI18next = function _reactI18next() {
+    return data;
+  };
+  return data;
+}
+var _ChartConfigure = require("./block/ChartConfigure");
+var _formatters = _interopRequireDefault(require("./block/formatters"));
+var _transformers = _interopRequireDefault(require("./block/transformers"));
+var _locale = require("./locale");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const useFields = collection => {
+  const _useContext = (0, _react2().useContext)(_ChartConfigure.ChartConfigContext),
+    current = _useContext.current;
+  if (!collection) {
+    collection = (current === null || current === void 0 ? void 0 : current.collection) || '';
+  }
+  const _useCollectionManager = (0, _client().useCollectionManager)(),
+    getCollectionFields = _useCollectionManager.getCollectionFields;
+  const fields = (getCollectionFields(collection) || []).filter(field => {
+    return field.interface;
+  }).map(field => {
+    var _field$uiSchema;
+    return _objectSpread(_objectSpread({}, field), {}, {
+      key: field.name,
+      label: ((_field$uiSchema = field.uiSchema) === null || _field$uiSchema === void 0 ? void 0 : _field$uiSchema.title) || field.name,
+      value: field.name
+    });
+  });
+  return fields;
+};
+exports.useFields = useFields;
+const useFieldsWithAssociation = collection => {
+  const _useCollectionManager2 = (0, _client().useCollectionManager)(),
+    getCollectionFields = _useCollectionManager2.getCollectionFields;
+  const _useTranslation = (0, _reactI18next().useTranslation)(),
+    t = _useTranslation.t;
+  const fields = useFields(collection);
+  return fields.map(field => {
+    var _field$uiSchema2;
+    const label = _react().Schema.compile(((_field$uiSchema2 = field.uiSchema) === null || _field$uiSchema2 === void 0 ? void 0 : _field$uiSchema2.title) || field.name, {
+      t
+    });
+    if (!field.target) {
+      return _objectSpread(_objectSpread({}, field), {}, {
+        label
+      });
+    }
+    const targetFields = (getCollectionFields(field.target) || []).filter(targetField => {
+      return targetField.interface;
+    }).map(targetField => {
+      var _targetField$uiSchema;
+      return _objectSpread(_objectSpread({}, targetField), {}, {
+        key: `${field.name}.${targetField.name}`,
+        label: `${label} / ${_react().Schema.compile(((_targetField$uiSchema = targetField.uiSchema) === null || _targetField$uiSchema === void 0 ? void 0 : _targetField$uiSchema.title) || targetField.name, {
+          t
+        })}`,
+        value: `${field.name}.${targetField.name}`
+      });
+    });
+    return _objectSpread(_objectSpread({}, field), {}, {
+      label,
+      targetFields
+    });
+  });
+};
+exports.useFieldsWithAssociation = useFieldsWithAssociation;
+const useChartFields = fields => field => {
+  const query = field.query('query').get('value') || {};
+  const selectedFields = (0, _utils.getSelectedFields)(fields, query);
+  field.dataSource = selectedFields;
+};
+exports.useChartFields = useChartFields;
+const useFormatters = fields => field => {
+  var _getField;
+  const selectedField = field.query('.field').get('value');
+  if (!selectedField) {
+    field.dataSource = [];
+    return;
+  }
+  let options = [];
+  const fieldInterface = (_getField = (0, _utils.getField)(fields, selectedField)) === null || _getField === void 0 ? void 0 : _getField.interface;
+  switch (fieldInterface) {
+    case 'datetime':
+    case 'createdAt':
+    case 'updatedAt':
+      options = _formatters.default.datetime;
+      break;
+    case 'date':
+      options = _formatters.default.date;
+      break;
+    case 'time':
+      options = _formatters.default.time;
+      break;
+    default:
+      options = [];
+  }
+  field.dataSource = options;
+};
+exports.useFormatters = useFormatters;
+const useCollectionOptions = () => {
+  const _useTranslation2 = (0, _reactI18next().useTranslation)(),
+    t = _useTranslation2.t;
+  const _useCollectionManager3 = (0, _client().useCollectionManager)(),
+    collections = _useCollectionManager3.collections;
+  const _useACLRoleContext = (0, _client().useACLRoleContext)(),
+    allowAll = _useACLRoleContext.allowAll,
+    parseAction = _useACLRoleContext.parseAction;
+  const options = collections.filter(collection => {
+    if (allowAll) {
+      return true;
+    }
+    const params = parseAction(`${collection.name}:list`);
+    return params;
+  }).map(collection => ({
+    label: collection.title,
+    value: collection.name,
+    key: collection.name
+  }));
+  return _react().Schema.compile(options, {
+    t
+  });
+};
+/**
+ * useFieldTypes
+ * Get field types for using transformers
+ * Only supported types will be displayed
+ * Some interfaces and types will be mapped to supported types
+ */
+exports.useCollectionOptions = useCollectionOptions;
+const useFieldTypes = fields => field => {
+  const selectedField = field.query('.field').get('value');
+  const query = field.query('query').get('value') || {};
+  const selectedFields = (0, _utils.getSelectedFields)(fields, query);
+  const fieldProps = selectedFields.find(field => field.value === selectedField);
+  const supports = Object.keys(_transformers.default);
+  field.dataSource = supports.map(key => ({
+    label: (0, _locale.lang)(key),
+    value: key
+  }));
+  const map = {
+    createdAt: 'datetime',
+    updatedAt: 'datetime',
+    double: 'number',
+    integer: 'number',
+    percent: 'number'
+  };
+  const fieldInterface = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.interface;
+  const fieldType = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.type;
+  const key = map[fieldInterface] || map[fieldType] || fieldType;
+  if (supports.includes(key)) {
+    field.setState({
+      value: key,
+      disabled: true
+    });
+    return;
+  }
+  field.setState({
+    value: null,
+    disabled: false
+  });
+};
+exports.useFieldTypes = useFieldTypes;
+const useTransformers = field => {
+  const selectedType = field.query('.type').get('value');
+  if (!selectedType) {
+    field.dataSource = [];
+    return;
+  }
+  const options = Object.keys(_transformers.default[selectedType] || {}).map(key => ({
+    label: (0, _locale.lang)(key),
+    value: key
+  }));
+  field.dataSource = options;
+};
+exports.useTransformers = useTransformers;
+const useFieldTransformer = (transform, locale = 'en-US') => {
+  return (transform || []).filter(item => item.field && item.type && item.format).reduce((mp, item) => {
+    const transformer = _transformers.default[item.type][item.format];
+    if (!transformer) {
+      return mp;
+    }
+    mp[item.field] = val => transformer(val, locale);
+    return mp;
+  }, {});
+};
+exports.useFieldTransformer = useFieldTransformer;
+const useOrderFieldsOptions = (defaultOptions, fields) => field => {
+  const query = field.query('query').get('value') || {};
+  const _query$measures = query.measures,
+    measures = _query$measures === void 0 ? [] : _query$measures;
+  const hasAgg = measures.some(measure => measure.aggregation);
+  if (!hasAgg) {
+    field.componentProps.fieldNames = {
+      label: 'title',
+      value: 'name',
+      children: 'children'
+    };
+    field.dataSource = defaultOptions;
+    return;
+  }
+  const selectedFields = (0, _utils.getSelectedFields)(fields, query);
+  field.componentProps.fieldNames = {};
+  field.dataSource = selectedFields;
+};
+exports.useOrderFieldsOptions = useOrderFieldsOptions;
+const useOrderReaction = (defaultOptions, fields) => field => {
+  const query = field.query('query').get('value') || {};
+  const _query$measures2 = query.measures,
+    measures = _query$measures2 === void 0 ? [] : _query$measures2;
+  const hasAgg = measures.some(measure => measure.aggregation);
+  let dataSource = defaultOptions;
+  const allValues = [];
+  if (hasAgg) {
+    dataSource = (0, _utils.getSelectedFields)(fields, query);
+    dataSource.forEach(field => {
+      allValues.push(field.value);
+    });
+  } else {
+    dataSource.forEach(field => {
+      const children = field.children || [];
+      if (!children.length) {
+        allValues.push(field.value || field.name);
+      }
+      children.forEach(child => {
+        allValues.push(`${field.name}.${child.name}`);
+      });
+    });
+  }
+  const orders = field.value || [];
+  const newOrders = orders.reduce((newOrders, item) => {
+    const _parseField = (0, _utils.parseField)(item.field),
+      alias = _parseField.alias;
+    if (!item.field || allValues.includes(alias)) {
+      newOrders.push(item);
+    }
+    return newOrders;
+  }, []);
+  field.setValue(newOrders);
+};
+exports.useOrderReaction = useOrderReaction;

package/lib/client/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ChartLibraryProvider } from './renderer/ChartLibrary';
+declare const Chart: React.FC;
+export default Chart;
+export { ChartLibraryProvider };

package/lib/client/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ChartLibraryProvider", {
+  enumerable: true,
+  get: function get() {
+    return _ChartLibrary.ChartLibraryProvider;
+  }
+});
+exports.default = void 0;
+function _client() {
+  const data = require("@nocobase/client");
+  _client = function _client() {
+    return data;
+  };
+  return data;
+}
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function _react() {
+    return data;
+  };
+  return data;
+}
+var _block = require("./block");
+var _locale = require("./locale");
+var _renderer = require("./renderer");
+var _ChartLibrary = require("./renderer/ChartLibrary");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+const Chart = props => {
+  const _useChartsTranslation = (0, _locale.useChartsTranslation)(),
+    t = _useChartsTranslation.t;
+  const initializers = (0, _react().useContext)(_client().SchemaInitializerContext);
+  const children = initializers.BlockInitializers.items[0].children;
+  const has = children.some(initializer => initializer.component === 'ChartV2BlockInitializer');
+  if (!has) {
+    children.push({
+      key: 'chart-v2',
+      type: 'item',
+      title: t('Chart'),
+      component: 'ChartV2BlockInitializer'
+    });
+  }
+  return _react().default.createElement(_client().SchemaComponentOptions, {
+    components: {
+      ChartV2BlockInitializer: _block.ChartV2BlockInitializer,
+      ChartRenderer: _renderer.ChartRenderer,
+      ChartV2BlockDesigner: _block.ChartV2BlockDesigner,
+      ChartV2Block: _block.ChartV2Block,
+      ChartRendererProvider: _renderer.ChartRendererProvider
+    }
+  }, _react().default.createElement(_client().SchemaInitializerProvider, {
+    initializers: _objectSpread(_objectSpread({}, initializers), {}, {
+      ChartInitializers: _block.ChartInitializers
+    })
+  }, _react().default.createElement(_ChartLibrary.ChartLibraryProvider, {
+    name: "Built-in",
+    charts: _renderer.InternalLibrary
+  }, props.children)));
+};
+var _default = Chart;
+exports.default = _default;

package/lib/client/locale/en-US.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    Edit: string;
+    Delete: string;
+    Cancel: string;
+    Submit: string;
+    Actions: string;
+    Title: string;
+    Enable: string;
+    'SAML manager': string;
+    'SAML Providers': string;
+    'Redirect url': string;
+    'SP entity id': string;
+    'Add provider': string;
+    'Edit provider': string;
+    'Client id': string;
+    'Entity id or issuer': string;
+    'Login Url': string;
+    'Public cert': string;
+    'Delete provider': string;
+    'Are you sure you want to delete it?': string;
+    'Sign in button name, which will be displayed on the sign in page': string;
+};
+export default _default;