@visactor/vbi 0.0.0

package/dist/index.cjs

@@ -0,0 +1,689 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    zVBIHavingFilter: ()=>zVBIHavingFilter,
+    zVBIHavingArray: ()=>zVBIHavingArray,
+    MeasuresBuilder: ()=>MeasuresBuilder,
+    DimensionsBuilder: ()=>DimensionsBuilder,
+    VBIBuilder: ()=>VBIBuilder,
+    ChartTypeBuilder: ()=>ChartTypeBuilder,
+    VBI: ()=>VBI,
+    preorderTraverse: ()=>vseed_namespaceObject.preorderTraverse,
+    buildVQuery: ()=>buildVQuery,
+    findTreeNodesBy: ()=>vseed_namespaceObject.findTreeNodesBy
+});
+const external_yjs_namespaceObject = require("yjs");
+class DimensionNodeBuilder {
+    yMap;
+    constructor(yMap){
+        this.yMap = yMap;
+    }
+    getField() {
+        return this.yMap.get('field');
+    }
+    setAlias(alias) {
+        this.yMap.set('alias', alias);
+        return this;
+    }
+    toJson() {
+        return this.yMap.toJSON();
+    }
+}
+class DimensionsBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    add(field, callback) {
+        const dimension = {
+            alias: field,
+            field
+        };
+        const yMap = new external_yjs_namespaceObject.Map();
+        for (const [key, value] of Object.entries(dimension))yMap.set(key, value);
+        this.dsl.get('dimensions').push([
+            yMap
+        ]);
+        const node = new DimensionNodeBuilder(yMap);
+        callback(node);
+        return this;
+    }
+    remove(field) {
+        const dimensions = this.dsl.get('dimensions');
+        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 !== index) this.dsl.get('dimensions').delete(index, 1);
+        return this;
+    }
+    update(field, callback) {
+        const dimensions = this.dsl.get('dimensions');
+        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) throw new Error(`Dimension with field "${field}" not found`);
+        const dimensionYMap = dimensions.get(index);
+        const node = new DimensionNodeBuilder(dimensionYMap);
+        callback(node);
+        return this;
+    }
+    find(field) {
+        const dimensions = this.dsl.get('dimensions');
+        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) return;
+        return new DimensionNodeBuilder(dimensions.get(index));
+    }
+    findAll() {
+        const dimensions = this.dsl.get('dimensions');
+        return dimensions.toArray().map((yMap)=>new DimensionNodeBuilder(yMap));
+    }
+    toJson() {
+        return this.dsl.get('dimensions').toJSON();
+    }
+    observe(callback) {
+        this.dsl.get('dimensions').observe(callback);
+        return ()=>{
+            this.dsl.get('dimensions').unobserve(callback);
+        };
+    }
+    static isDimensionNode(node) {
+        return 'alias' in node && !('children' in node);
+    }
+    static isDimensionGroup(node) {
+        return 'children' in node;
+    }
+}
+class MeasureNodeBuilder {
+    yMap;
+    constructor(yMap){
+        this.yMap = yMap;
+    }
+    getField() {
+        return this.yMap.get('field');
+    }
+    setAlias(alias) {
+        this.yMap.set('alias', alias);
+        return this;
+    }
+    setEncoding(encoding) {
+        this.yMap.set('encoding', encoding);
+        return this;
+    }
+    setAggregate(aggregate) {
+        this.yMap.set('aggregate', aggregate);
+        return this;
+    }
+    toJson() {
+        return this.yMap.toJSON();
+    }
+}
+class MeasuresBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    add(field, callback) {
+        const measure = {
+            alias: field,
+            field,
+            encoding: 'yAxis',
+            aggregate: {
+                func: 'sum'
+            }
+        };
+        const yMap = new external_yjs_namespaceObject.Map();
+        for (const [key, value] of Object.entries(measure))yMap.set(key, value);
+        this.dsl.get('measures').push([
+            yMap
+        ]);
+        const node = new MeasureNodeBuilder(yMap);
+        callback(node);
+        return this;
+    }
+    remove(field) {
+        const measures = this.dsl.get('measures');
+        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 !== index) this.dsl.get('measures').delete(index, 1);
+        return this;
+    }
+    update(field, callback) {
+        const measures = this.dsl.get('measures');
+        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) throw new Error(`Measure with field "${field}" not found`);
+        const measureYMap = measures.get(index);
+        const node = new MeasureNodeBuilder(measureYMap);
+        callback(node);
+        return this;
+    }
+    find(field) {
+        const measures = this.dsl.get('measures');
+        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) return;
+        return new MeasureNodeBuilder(measures.get(index));
+    }
+    findAll() {
+        const measures = this.dsl.get('measures');
+        return measures.toArray().map((yMap)=>new MeasureNodeBuilder(yMap));
+    }
+    toJson() {
+        return this.dsl.get('measures').toJSON();
+    }
+    observe(callback) {
+        this.dsl.get('measures').observe(callback);
+        return ()=>{
+            this.dsl.get('measures').unobserve(callback);
+        };
+    }
+    static isMeasureNode(node) {
+        return 'encoding' in node || 'aggregate' in node;
+    }
+    static isMeasureGroup(node) {
+        return 'children' in node;
+    }
+}
+class HavingFiltersNodeBuilder {
+    yMap;
+    constructor(yMap){
+        this.yMap = yMap;
+    }
+    getField() {
+        return this.yMap.get('field');
+    }
+    setValue(value) {
+        this.yMap.set('value', value);
+        return this;
+    }
+    setOperator(operator) {
+        this.yMap.set('operator', operator);
+        return this;
+    }
+    toJson() {
+        return this.yMap.toJSON();
+    }
+}
+class HavingFiltersBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    add(field, callback) {
+        if (!field || 'string' != typeof field) throw new Error('Field is required and must be a string');
+        const defaultFilter = {
+            field,
+            operator: 'eq',
+            value: null
+        };
+        const yMap = new external_yjs_namespaceObject.Map();
+        for (const [key, value] of Object.entries(defaultFilter))yMap.set(key, value);
+        this.dsl.get('havingFilters').push([
+            yMap
+        ]);
+        const filterNode = new HavingFiltersNodeBuilder(yMap);
+        callback(filterNode);
+        return this;
+    }
+    update(field, callback) {
+        const havingFilters = this.dsl.get('havingFilters');
+        const index = havingFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) throw new Error(`Having filter with field "${field}" not found`);
+        const filterYMap = havingFilters.get(index);
+        const node = new HavingFiltersNodeBuilder(filterYMap);
+        callback(node);
+        return this;
+    }
+    remove(field) {
+        if (!field || 'string' != typeof field) console.error('[HavingFiltersBuilder] Invalid field name:', field);
+        const havingFilters = this.dsl.get('havingFilters');
+        const index = havingFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 !== index) this.dsl.get('havingFilters').delete(index, 1);
+        return this;
+    }
+    find(field) {
+        const havingFilters = this.dsl.get('havingFilters');
+        const index = havingFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) return;
+        return new HavingFiltersNodeBuilder(havingFilters.get(index));
+    }
+    findAll() {
+        const havingFilters = this.dsl.get('havingFilters');
+        return havingFilters.toArray().map((yMap)=>new HavingFiltersNodeBuilder(yMap));
+    }
+    clear() {
+        const havingFilters = this.dsl.get('havingFilters');
+        if (havingFilters.length > 0) havingFilters.delete(0, havingFilters.length);
+        return this;
+    }
+    toJson() {
+        return this.dsl.get('havingFilters').toJSON();
+    }
+    observe(callback) {
+        this.dsl.get('havingFilters').observe(callback);
+        return ()=>{
+            this.dsl.get('havingFilters').unobserve(callback);
+        };
+    }
+}
+const vseed_namespaceObject = require("@visactor/vseed");
+class ChartTypeBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    observe(callback) {
+        const wrapper = (e, trans)=>{
+            if (e.keysChanged.has('chartType')) callback(e, trans);
+        };
+        this.dsl.observe(wrapper);
+        return ()=>{
+            this.dsl.unobserve(wrapper);
+        };
+    }
+    changeChartType(chartType) {
+        this.dsl.set('chartType', chartType);
+    }
+    getChartType() {
+        return this.dsl.get('chartType') || 'table';
+    }
+    toJson() {
+        return this.dsl.get('chartType') || 'table';
+    }
+    getAvailableChartTypes() {
+        return [
+            vseed_namespaceObject.ChartTypeEnum.Table,
+            vseed_namespaceObject.ChartTypeEnum.PivotTable,
+            vseed_namespaceObject.ChartTypeEnum.Line,
+            vseed_namespaceObject.ChartTypeEnum.Column,
+            vseed_namespaceObject.ChartTypeEnum.ColumnPercent,
+            vseed_namespaceObject.ChartTypeEnum.ColumnParallel,
+            vseed_namespaceObject.ChartTypeEnum.BarPercent,
+            vseed_namespaceObject.ChartTypeEnum.BarParallel,
+            vseed_namespaceObject.ChartTypeEnum.Area,
+            vseed_namespaceObject.ChartTypeEnum.AreaPercent,
+            vseed_namespaceObject.ChartTypeEnum.DualAxis,
+            vseed_namespaceObject.ChartTypeEnum.Scatter,
+            vseed_namespaceObject.ChartTypeEnum.Rose,
+            vseed_namespaceObject.ChartTypeEnum.RoseParallel,
+            vseed_namespaceObject.ChartTypeEnum.Pie,
+            vseed_namespaceObject.ChartTypeEnum.Donut,
+            vseed_namespaceObject.ChartTypeEnum.Radar,
+            vseed_namespaceObject.ChartTypeEnum.Funnel,
+            vseed_namespaceObject.ChartTypeEnum.Heatmap,
+            vseed_namespaceObject.ChartTypeEnum.Boxplot,
+            vseed_namespaceObject.ChartTypeEnum.Histogram
+        ];
+    }
+}
+class WhereFilterNodeBuilder {
+    yMap;
+    constructor(yMap){
+        this.yMap = yMap;
+    }
+    getField() {
+        return this.yMap.get('field');
+    }
+    setOperator(operator) {
+        this.yMap.set('operator', operator);
+        return this;
+    }
+    setValue(value) {
+        this.yMap.set('value', value);
+        return this;
+    }
+    toJson() {
+        return this.yMap.toJSON();
+    }
+}
+class WhereFiltersBuilder {
+    dsl;
+    doc;
+    constructor(doc, dsl){
+        this.doc = doc;
+        this.dsl = dsl;
+        if (!this.dsl.get('whereFilters')) this.doc.transact(()=>{
+            this.dsl.set('whereFilters', new external_yjs_namespaceObject.Array());
+        });
+    }
+    add(field, callback) {
+        const filter = {
+            field
+        };
+        const yMap = new external_yjs_namespaceObject.Map();
+        for (const [key, value] of Object.entries(filter))yMap.set(key, value);
+        this.dsl.get('whereFilters').push([
+            yMap
+        ]);
+        const node = new WhereFilterNodeBuilder(yMap);
+        callback(node);
+        return this;
+    }
+    update(field, callback) {
+        const whereFilters = this.dsl.get('whereFilters');
+        const index = whereFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) throw new Error(`Where filter with field ${field} not found`);
+        const filterYMap = whereFilters.get(index);
+        const node = new WhereFilterNodeBuilder(filterYMap);
+        callback(node);
+        return this;
+    }
+    remove(field) {
+        const whereFilters = this.dsl.get('whereFilters');
+        const index = whereFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) return this;
+        whereFilters.delete(index, 1);
+        return this;
+    }
+    find(field) {
+        const whereFilters = this.dsl.get('whereFilters');
+        const index = whereFilters.toArray().findIndex((item)=>item.get('field') === field);
+        if (-1 === index) return;
+        return new WhereFilterNodeBuilder(whereFilters.get(index));
+    }
+    findAll() {
+        const whereFilters = this.dsl.get('whereFilters');
+        return whereFilters.toArray().map((yMap)=>new WhereFilterNodeBuilder(yMap));
+    }
+    clear() {
+        const whereFilters = this.dsl.get('whereFilters');
+        whereFilters.delete(0, whereFilters.length);
+        return this;
+    }
+    toJson() {
+        return this.dsl.get('whereFilters').toJSON();
+    }
+    observe(callback) {
+        this.dsl.get('whereFilters').observe(callback);
+        return ()=>{
+            this.dsl.get('whereFilters').unobserve(callback);
+        };
+    }
+}
+const external_zod_namespaceObject = require("zod");
+const zVBIHavingFilter = external_zod_namespaceObject.z.object({
+    field: external_zod_namespaceObject.z.string(),
+    operator: external_zod_namespaceObject.z.string().optional(),
+    value: external_zod_namespaceObject.z.any().optional()
+});
+const zVBIHavingArray = external_zod_namespaceObject.z.array(zVBIHavingFilter);
+const external_remeda_namespaceObject = require("remeda");
+const buildVQuery = (vbiDSL, builder)=>{
+    const wrapper = (processor)=>(queryDSL)=>processor(queryDSL, {
+                vbiDSL,
+                builder
+            });
+    return (0, external_remeda_namespaceObject.pipe)({}, wrapper(buildSelect), wrapper(buildGroupBy), wrapper(buildWhere), wrapper(buildHaving), wrapper(buildOrderBy), wrapper(buildLimit));
+};
+const buildWhere = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const whereFilters = vbiDSL.whereFilters || [];
+    if (0 === whereFilters.length) return queryDSL;
+    const result = {
+        ...queryDSL
+    };
+    result.where = {
+        op: 'and',
+        conditions: whereFilters.flatMap((filter)=>{
+            if ('between' === filter.operator && filter.value && 'object' == typeof filter.value && !Array.isArray(filter.value)) {
+                const conditions = [];
+                if (void 0 !== filter.value.min && null !== filter.value.min && '' !== filter.value.min) conditions.push({
+                    field: filter.field,
+                    op: '<' === filter.value.leftOp ? '>' : '>=',
+                    value: filter.value.min
+                });
+                if (void 0 !== filter.value.max && null !== filter.value.max && '' !== filter.value.max) conditions.push({
+                    field: filter.field,
+                    op: '<' === filter.value.rightOp ? '<' : '<=',
+                    value: filter.value.max
+                });
+                return conditions;
+            }
+            let mappedOp = filter.operator ?? '=';
+            if (Array.isArray(filter.value)) {
+                if ('=' === mappedOp) mappedOp = 'in';
+                if ('!=' === mappedOp) mappedOp = 'not in';
+            }
+            return [
+                {
+                    field: filter.field,
+                    op: mappedOp,
+                    value: filter.value
+                }
+            ];
+        })
+    };
+    return result;
+};
+const buildOrderBy = (queryDSL, context)=>queryDSL;
+const buildSelect = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const measures = vbiDSL.measures;
+    const dimensions = vbiDSL.dimensions;
+    const result = {
+        ...queryDSL
+    };
+    const measureNodes = measures.filter((measure)=>MeasuresBuilder.isMeasureNode(measure));
+    const measureSelects = measureNodes.map((measure)=>({
+            field: measure.field,
+            alias: measure.alias,
+            aggr: measure.aggregate
+        }));
+    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
+    const dimensionSelects = dimensionNodes.map((dimension)=>({
+            field: dimension.field,
+            alias: dimension.alias
+        }));
+    result.select = measureSelects.concat(dimensionSelects);
+    return result;
+};
+const buildGroupBy = (queryDSL, context)=>{
+    const result = {
+        ...queryDSL
+    };
+    const { vbiDSL } = context;
+    const dimensions = vbiDSL.dimensions;
+    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
+    result.groupBy = dimensionNodes.map((dimension)=>dimension.field);
+    return result;
+};
+const buildLimit = (queryDSL, context)=>{
+    const result = {
+        ...queryDSL
+    };
+    const limit = context.vbiDSL.limit ?? 1000;
+    result.limit = limit;
+    return result;
+};
+const buildHaving = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const havingFilters = vbiDSL.havingFilters || [];
+    if (0 === havingFilters.length) return queryDSL;
+    const result = {
+        ...queryDSL
+    };
+    result.having = {
+        op: 'and',
+        conditions: havingFilters.map((filter)=>{
+            const mappedOp = filter.operator ?? '=';
+            return {
+                field: filter.field,
+                op: mappedOp,
+                value: filter.value
+            };
+        })
+    };
+    return result;
+};
+const connectorMap = new Map();
+const registerConnector = (id, connector)=>{
+    connectorMap.set(id, connector);
+};
+const getConnector = async (id)=>{
+    const connector = connectorMap.get(id);
+    if (!connector) throw new Error(`connector ${id} not registered`);
+    if ('function' == typeof connector) return connector();
+    return connector;
+};
+class VBIBuilder {
+    doc;
+    dsl;
+    undoManager;
+    chartType;
+    measures;
+    dimensions;
+    havingFilters;
+    whereFilters;
+    constructor(doc){
+        this.doc = doc;
+        this.dsl = doc.getMap('dsl');
+        this.undoManager = new external_yjs_namespaceObject.UndoManager(this.dsl);
+        this.chartType = new ChartTypeBuilder(doc, this.dsl);
+        this.measures = new MeasuresBuilder(doc, this.dsl);
+        this.dimensions = new DimensionsBuilder(doc, this.dsl);
+        this.havingFilters = new HavingFiltersBuilder(doc, this.dsl);
+        this.whereFilters = new WhereFiltersBuilder(doc, this.dsl);
+    }
+    applyUpdate(update) {
+        external_yjs_namespaceObject.applyUpdate(this.doc, update);
+    }
+    encodeStateAsUpdate(targetStateVector) {
+        return external_yjs_namespaceObject.encodeStateAsUpdate(this.doc, targetStateVector);
+    }
+    buildVSeed = async ()=>{
+        const vbiDSL = this.build();
+        const connectorId = vbiDSL.connectorId;
+        const connector = await getConnector(vbiDSL.connectorId);
+        const queryDSL = this.buildVQuery();
+        const schema = await connector.discoverSchema();
+        const queryResult = await connector.query({
+            queryDSL,
+            schema,
+            connectorId
+        });
+        return {
+            chartType: vbiDSL.chartType,
+            dataset: queryResult.dataset,
+            theme: vbiDSL.theme,
+            locale: vbiDSL.locale
+        };
+    };
+    buildVQuery = ()=>{
+        const vbiDSL = this.build();
+        return buildVQuery(vbiDSL, this);
+    };
+    build = ()=>this.dsl.toJSON();
+    getSchema = async ()=>{
+        const connectorId = this.dsl.get('connectorId');
+        const con = await getConnector(connectorId);
+        const result = await con.discoverSchema();
+        return result;
+    };
+    setLimit(limit) {
+        this.dsl.set('limit', limit);
+        return this;
+    }
+    setLocale(locale) {
+        this.dsl.set('locale', locale);
+        return this;
+    }
+    setTheme(theme) {
+        this.dsl.set('theme', theme);
+        return this;
+    }
+}
+const createVBI = ()=>({
+        connectorMap: connectorMap,
+        registerConnector: registerConnector,
+        getConnector: getConnector,
+        generateEmptyDSL: (connectorId)=>({
+                connectorId: connectorId,
+                chartType: 'table',
+                measures: [],
+                dimensions: [],
+                whereFilters: [],
+                havingFilters: [],
+                theme: 'light',
+                locale: 'zh-CN',
+                version: 0
+            }),
+        from: (vbi)=>{
+            const doc = new external_yjs_namespaceObject.Doc();
+            const dsl = doc.getMap('dsl');
+            doc.transact(()=>{
+                if (vbi.connectorId) dsl.set('connectorId', vbi.connectorId);
+                if (vbi.chartType) dsl.set('chartType', vbi.chartType);
+                if (vbi.theme) dsl.set('theme', vbi.theme);
+                if (vbi.limit) dsl.set('limit', vbi.limit);
+                if (vbi.locale) dsl.set('locale', vbi.locale);
+                if (vbi.version) dsl.set('version', vbi.version);
+                const ensureYArray = (arr)=>{
+                    if (!arr) return new external_yjs_namespaceObject.Array();
+                    if (arr instanceof external_yjs_namespaceObject.Array) return arr;
+                    const yArr = new external_yjs_namespaceObject.Array();
+                    arr.forEach((item)=>{
+                        if (item instanceof external_yjs_namespaceObject.Map) yArr.push([
+                            item
+                        ]);
+                        else if ('object' == typeof item && null !== item) {
+                            const yMap = new external_yjs_namespaceObject.Map();
+                            for (const [key, value] of Object.entries(item))yMap.set(key, value);
+                            yArr.push([
+                                yMap
+                            ]);
+                        } else yArr.push([
+                            item
+                        ]);
+                    });
+                    return yArr;
+                };
+                dsl.set('whereFilters', ensureYArray(vbi.whereFilters));
+                dsl.set('havingFilters', ensureYArray(vbi.havingFilters));
+                dsl.set('measures', ensureYArray(vbi.measures));
+                dsl.set('dimensions', ensureYArray(vbi.dimensions));
+            });
+            return new VBIBuilder(doc);
+        }
+    });
+const VBI = createVBI();
+exports.ChartTypeBuilder = __webpack_exports__.ChartTypeBuilder;
+exports.DimensionsBuilder = __webpack_exports__.DimensionsBuilder;
+exports.MeasuresBuilder = __webpack_exports__.MeasuresBuilder;
+exports.VBI = __webpack_exports__.VBI;
+exports.VBIBuilder = __webpack_exports__.VBIBuilder;
+exports.buildVQuery = __webpack_exports__.buildVQuery;
+exports.findTreeNodesBy = __webpack_exports__.findTreeNodesBy;
+exports.preorderTraverse = __webpack_exports__.preorderTraverse;
+exports.zVBIHavingArray = __webpack_exports__.zVBIHavingArray;
+exports.zVBIHavingFilter = __webpack_exports__.zVBIHavingFilter;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ChartTypeBuilder",
+    "DimensionsBuilder",
+    "MeasuresBuilder",
+    "VBI",
+    "VBIBuilder",
+    "buildVQuery",
+    "findTreeNodesBy",
+    "preorderTraverse",
+    "zVBIHavingArray",
+    "zVBIHavingFilter"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { VBIBuilder, VBI } from './builder';
+export { MeasuresBuilder, DimensionsBuilder, ChartTypeBuilder } from './builder';
+export * from './types';
+export * from './utils';
+export * from './pipeline';