@vuu-ui/vuu-data-test 4.1.0 → 5.0.0-alpha.1

package/src/basket/reference-data/constituents.js

@@ -1,76 +1,8 @@
-import ftse100 from "./ftse100.js";
-import nasdaq100 from "./nasdaq100.js";
-import sp500 from "./sp500.js";
-import hsi from "./hsi.js";
-const basketConstituentData = [];
-for (const row of ftse100){
-    const [ric, name, lastTrade, change, volume] = row;
-    const basketId = ".FTSE100";
-    const side = "BUY";
-    const weighting = 1;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of hsi){
-    const [name, ric, lastTrade, change, , volume] = row;
-    const basketId = ".HSI";
-    const side = "BUY";
-    const weighting = 1;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of nasdaq100){
-    const [name, ric, weighting, lastTrade, change] = row;
-    const basketId = ".NASDAQ100";
-    const side = "BUY";
-    const volume = 1000;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
-for (const row of sp500){
-    const [name, ric, weighting, , change] = row;
-    const basketId = ".SP500";
-    const side = "BUY";
-    const volume = 1000;
-    const lastTrade = 0;
-    basketConstituentData.push([
-        basketId,
-        change,
-        name,
-        lastTrade,
-        ric,
-        `${ric}-${basketId}`,
-        side,
-        volume,
-        weighting
-    ]);
-}
+import constituent_data from "./constituent-data.js";
+import { schemas } from "../basket-schemas.js";
+const basketConstituentData = constituent_data.map((constituent)=>{
+    const values = constituent;
+    return schemas.basketConstituent.columns.map(({ name })=>values[name]);
+});
 const constituents = basketConstituentData;
 export default constituents;

package/src/basket/reference-data/prices.js

@@ -1,9 +1,8 @@
-import { buildDataColumnMap } from "../../Table.js";
+import { Table, buildDataColumnMap } from "../../Table.js";
 import { BaseUpdateGenerator } from "../../UpdateGenerator.js";
 import { schemas } from "../../simul/simul-schemas.js";
 import constituents from "./constituents.js";
 import { initBidAsk, nextRandomDouble, random } from "../../data-utils.js";
-import TableContainer from "../../core/table/TableContainer.js";
 const { bid: prices_bid, bidSize: prices_bidSize, ask: prices_ask, askSize: prices_askSize, last: prices_last } = buildDataColumnMap(schemas, "prices");
 const pricesUpdateGenerator = new BaseUpdateGenerator({
     bid: prices_bid,
@@ -13,9 +12,12 @@ const pricesUpdateGenerator = new BaseUpdateGenerator({
     last: prices_last
 });
 const prices = [];
+const seen = new Set();
 for (const [, , , lastTrade, ric] of constituents){
+    if (seen.has(String(ric))) continue;
     const priceSeed = parseFloat(String(lastTrade));
     if (!isNaN(priceSeed)) {
+        seen.add(String(ric));
         const [bid, ask] = initBidAsk(5, nextRandomDouble);
         const askSize = random(1000, 3000);
         const bidSize = random(1000, 3000);
@@ -38,6 +40,10 @@ for (const [, , , lastTrade, ric] of constituents){
         ]);
     }
 }
-const pricesTable = TableContainer.createTable(schemas.prices, prices, buildDataColumnMap(schemas, "prices"), pricesUpdateGenerator);
+const pricesTable = new Table(schemas.prices, prices, buildDataColumnMap(schemas, "prices"), pricesUpdateGenerator);
+pricesUpdateGenerator.setRange({
+    from: 0,
+    to: prices.length
+});
 const reference_data_prices = pricesTable;
 export default reference_data_prices;

package/src/core/filter/PermissionFilter.js

@@ -0,0 +1,60 @@
+const allowAll = ()=>true;
+const denyAll = ()=>false;
+const AllowAllPermissionFilter = {
+    createPredicate: ()=>allowAll
+};
+const DenyAllPermissionFilter = {
+    createPredicate: ()=>denyAll
+};
+class RowPermissionFilter {
+    rowPredicate;
+    constructor(rowPredicate){
+        this.rowPredicate = rowPredicate;
+    }
+    createPredicate(columnMap) {
+        let currentRow = [];
+        const rowData = {
+            get: (columnName)=>{
+                const idx = columnMap[columnName];
+                return void 0 === idx ? void 0 : currentRow[idx];
+            }
+        };
+        return (row)=>{
+            currentRow = row;
+            return this.rowPredicate(rowData);
+        };
+    }
+}
+class ContainsPermissionFilter {
+    columnName;
+    allowedValues;
+    constructor(columnName, allowedValues){
+        this.columnName = columnName;
+        this.allowedValues = allowedValues;
+    }
+    createPredicate(columnMap) {
+        const idx = columnMap[this.columnName];
+        if (void 0 === idx || 0 === this.allowedValues.size) return denyAll;
+        const { allowedValues } = this;
+        return (row)=>{
+            const value = row[idx];
+            return null != value && allowedValues.has(String(value));
+        };
+    }
+}
+class PermissionFilterChain {
+    filters;
+    constructor(filters){
+        this.filters = filters;
+    }
+    createPredicate(columnMap) {
+        const predicates = this.filters.map((f)=>f.createPredicate(columnMap));
+        return (row)=>predicates.every((predicate)=>predicate(row));
+    }
+}
+function PermissionFilter(arg, allowedValues) {
+    if ("function" == typeof arg) return new RowPermissionFilter(arg);
+    if ("string" == typeof arg) return new ContainsPermissionFilter(arg, allowedValues ?? new Set());
+    return new PermissionFilterChain(Array.from(arg));
+}
+export { AllowAllPermissionFilter, DenyAllPermissionFilter, PermissionFilter };

package/src/core/filter/PermissionFilteredTable.js

@@ -0,0 +1,59 @@
+import { Table } from "../../Table.js";
+class PermissionFilteredTable extends Table {
+    #attached = false;
+    #indexOfKey;
+    #predicate;
+    #source;
+    constructor(source, predicate){
+        super(source.schema, source.data.filter(predicate), source.map);
+        this.#indexOfKey = source.map[source.schema.key];
+        this.#predicate = predicate;
+        this.#source = source;
+        this.attach();
+    }
+    get source() {
+        return this.#source;
+    }
+    attach() {
+        if (!this.#attached) {
+            this.#source.on("insert", this.handleSourceInsert);
+            this.#source.on("update", this.handleSourceUpdate);
+            this.#source.on("delete", this.handleSourceDelete);
+            this.#attached = true;
+        }
+    }
+    dispose() {
+        if (this.#attached) {
+            this.#source.removeListener("insert", this.handleSourceInsert);
+            this.#source.removeListener("update", this.handleSourceUpdate);
+            this.#source.removeListener("delete", this.handleSourceDelete);
+            this.#attached = false;
+        }
+    }
+    contains(key) {
+        return void 0 !== this.findByKey(key);
+    }
+    handleSourceInsert = (row)=>{
+        if (this.#predicate(row)) this.insert(row);
+    };
+    handleSourceUpdate = (row)=>{
+        const key = row[this.#indexOfKey];
+        const isMember = this.contains(key);
+        const isPermitted = this.#predicate(row);
+        if (isMember && isPermitted) this.replaceRow(row);
+        else if (isMember) this.delete(key);
+        else if (isPermitted) this.insert(row);
+    };
+    handleSourceDelete = (key)=>{
+        if (this.contains(key)) this.delete(key);
+    };
+    replaceRow(row) {
+        const key = row[this.#indexOfKey];
+        const rowIndex = this.data.findIndex((r)=>r[this.#indexOfKey] === key);
+        if (-1 !== rowIndex) {
+            this.data[rowIndex] = row;
+            this.emit("update", row);
+        }
+    }
+}
+export { PermissionFilteredTable };

package/src/core/module/ModuleContainer.js

@@ -8,6 +8,9 @@ class ModuleContainer {
     register(module) {
         this.#modules.set(module.name, module);
     }
+    has(name) {
+        return this.#modules.has(name);
+    }
     get(name) {
         const module = this.#modules.get(name);
         if (module) return module;
@@ -18,4 +21,9 @@ class ModuleContainer {
     }
 }
 const module_ModuleContainer = ModuleContainer.instance;
+const ensureVuuModule = (module)=>{
+    if (!ModuleContainer.instance.has(module.name)) ModuleContainer.instance.register(module);
+    return module;
+};
 export default module_ModuleContainer;
+export { ensureVuuModule };

package/src/core/module/VuuModule.js

@@ -4,6 +4,10 @@ import { TickingArrayDataSource } from "../../TickingArrayDataSource.js";
 import { RuntimeVisualLink } from "../../RuntimeVisualLink.js";
 import ModuleContainer from "./ModuleContainer.js";
 import { sessionTableRow, sessionTableSchema } from "../../session-table-utils.js";
+import { AllowAllPermissionFilter } from "../filter/PermissionFilter.js";
+import { PermissionFilteredTable } from "../filter/PermissionFilteredTable.js";
+import { getCurrentUser } from "../user/CurrentUser.js";
+import TableContainer from "../table/TableContainer.js";
 const assertUpdateIsValid = (schema, column, _data)=>{
     const col = schema.columns.find((col)=>col.name === column);
     if (col) ;
@@ -22,6 +26,12 @@ class VuuModule {
         this.#sessionTableMessageColumn = sessionTableMessageColumn;
         ModuleContainer.register(this);
     }
+    get includeDefaultServices() {
+        return true;
+    }
+    async beforeSessionSave(_sourceTable, _sessionTable) {}
+    async afterSessionSave(_sourceTable, _sessionTable) {}
+    permissionFunctions;
     getTableSchema(tableName) {
         return this.schemas[tableName] ?? this.#sessionTableMap[tableName]?.schema;
     }
@@ -121,9 +131,17 @@ class VuuModule {
         return void 0 === linksForTable ? void 0 : this.getLinks(this.#subscriptionMap, linksForTable);
     };
     createDataSource = (tableName, viewport, config)=>{
+        this.beforeCreateDataSource?.(tableName);
         const columnDescriptors = this.getColumnDescriptors(tableName);
-        const table = this.tables[tableName];
         const sessionTable = this.#sessionTableMap[tableName];
+        const user = getCurrentUser();
+        const permissionFunction = sessionTable ? void 0 : this.permissionFunctions?.[tableName];
+        const viewportId = permissionFunction ? viewport ?? uuid() : viewport;
+        const permissionFilteredTable = permissionFunction ? this.createPermissionFilteredTable(this.tables[tableName], permissionFunction, {
+            id: viewportId,
+            user
+        }) : void 0;
+        const table = permissionFilteredTable ?? this.tables[tableName];
         const vuuModule = this;
         const dataSource = new TickingArrayDataSource({
             ...config,
@@ -134,18 +152,24 @@ class VuuModule {
             menu: this.menus?.[tableName],
             rpcServices: this.getServices(tableName),
             rpcMenuServices: this.getMenuServices(tableName),
-            viewport,
+            viewport: viewportId,
             visualLinkService: this.visualLinkService,
             vuuModule
         });
         dataSource.on("subscribed", this.handlePostSubscribeActivities);
         dataSource.on("unsubscribed", this.unregisterViewport);
+        if (permissionFilteredTable) {
+            dataSource.on("subscribed", ()=>permissionFilteredTable.attach());
+            dataSource.on("unsubscribed", ()=>permissionFilteredTable.dispose());
+        }
         const existingSubscriptions = this.#subscriptionMap.get(tableName);
         const subscription = {
             viewportId: dataSource.viewport,
             dataSource,
             sessionTableName: sessionTable ? tableName : void 0,
-            sourceTableName: this.#sessionSourceTableMap[tableName]
+            sourceTableName: this.#sessionSourceTableMap[tableName],
+            table: table || sessionTable,
+            user
         };
         if (existingSubscriptions) existingSubscriptions.push(subscription);
         else this.#subscriptionMap.set(tableName, [
@@ -153,10 +177,16 @@ class VuuModule {
         ]);
         return dataSource;
     };
+    createPermissionFilteredTable(table, permissionFunction, viewport) {
+        const permissionFilter = permissionFunction(viewport, TableContainer);
+        if (permissionFilter === AllowAllPermissionFilter) return;
+        return new PermissionFilteredTable(table, permissionFilter.createPredicate(table.map));
+    }
     getServices(tableName) {
         const tableServices = this.services?.[tableName];
-        if (Array.isArray(tableServices)) return this.#moduleServices.concat(tableServices);
-        return this.#moduleServices;
+        const defaultServices = this.includeDefaultServices ? this.#moduleServices : [];
+        if (Array.isArray(tableServices)) return defaultServices.concat(tableServices);
+        return defaultServices;
     }
     getMenuServices(tableName) {
         const tableServices = this.menuServices?.[tableName];
@@ -265,7 +295,9 @@ class VuuModule {
                     sessionTable.delete(key);
                     return {
                         type: "SUCCESS_RESULT",
-                        data: void 0
+                        data: {
+                            wasInsertedRow: true
+                        }
                     };
                 }
                 if ("deleteRow" === action || "editCell" === action) {
@@ -499,6 +531,14 @@ class VuuModule {
                     data: void 0
                 };
                 {
+                    try {
+                        await this.beforeSessionSave(sourceTable, sessionTable);
+                    } catch (error) {
+                        return {
+                            errorMessage: error instanceof Error ? error.message : "Unable to prepare session changes",
+                            type: "ERROR_RESULT"
+                        };
+                    }
                     let rejectedCount = 0;
                     const vuuMsgIdx = sessionTable.map[this.#sessionTableMessageColumn];
                     const actionIdx = sessionTable.map.vuuAction;
@@ -533,6 +573,14 @@ class VuuModule {
                         errorMessage: "stale update",
                         type: "ERROR_RESULT"
                     };
+                    try {
+                        await this.afterSessionSave(sourceTable, sessionTable);
+                    } catch (error) {
+                        return {
+                            errorMessage: error instanceof Error ? error.message : "Unable to finalize session changes",
+                            type: "ERROR_RESULT"
+                        };
+                    }
                     return {
                         type: "SUCCESS_RESULT",
                         data: void 0

package/src/core/table/TableContainer.js

@@ -10,14 +10,14 @@ class TableContainer {
         return TableContainer.#instance;
     }
     #tables = new Map();
-    createTable = (schema, data, dataMap, updateGenerator)=>{
+    createTable = (schema, data = [], dataMap = buildDataColumnMapFromSchema(schema), updateGenerator)=>{
         const table = new Table(schema, data, dataMap, updateGenerator);
         this.addTable(table);
         return table;
     };
-    createJoinTable(joinTable, { table: t1 }, { table: t2 }, joinColumn) {
-        const table1 = this.getTable(t1);
-        const table2 = this.getTable(t2);
+    createJoinTable(joinTable, source1, source2, joinColumn) {
+        const table1 = source1 instanceof Table ? source1 : this.getTable(source1.table);
+        const table2 = source2 instanceof Table ? source2 : this.getTable(source2.table);
         const { map: m1, schema: schema1 } = table1;
         const { map: m2, schema: schema2 } = table2;
         const k1 = m1[joinColumn];
@@ -27,7 +27,7 @@ class TableContainer {
             ...schema2.columns
         ].map((col)=>col.name).sort());
         const combinedSchema = {
-            key: joinColumn,
+            key: schema1.key,
             table: joinTable,
             rangeLimits: DEFAULT_RANGE_LIMITS,
             columns: Array.from(combinedColumns).map((columnName)=>({
@@ -53,6 +53,18 @@ class TableContainer {
             }
         }
         const newTable = new Table(combinedSchema, data, combinedColumnMap);
+        const joinedKeys = new Map();
+        const indexJoinedRow = (row)=>{
+            const value = String(row[combinedColumnMap[joinColumn]]);
+            const key = String(row[combinedColumnMap[schema1.key]]);
+            let keys = joinedKeys.get(value);
+            if (!keys) {
+                keys = new Set();
+                joinedKeys.set(value, keys);
+            }
+            keys.add(key);
+        };
+        data.forEach(indexJoinedRow);
         table1.on("insert", (row)=>{
             const row2 = table2.findByKey(String(row[k1]));
             if (row2) {
@@ -65,18 +77,49 @@ class TableContainer {
                     const value = row2[m2[column.name]];
                     out[combinedColumnMap[column.name]] = value;
                 }
+                indexJoinedRow(out);
                 newTable.insert(out);
             }
         });
-        table2.on("update", (row)=>{
-            const keyValue = row[k2];
-            const targetRow = newTable.findByKey(keyValue);
+        table1.on("update", (row)=>{
+            const key = String(row[m1[schema1.key]]);
+            const targetRow = newTable.findByKey(key);
             if (targetRow) {
                 const updatedRow = targetRow.slice();
-                for (const { name } of table2.schema.columns)if (row[m2[name]] !== updatedRow[combinedColumnMap[name]]) updatedRow[combinedColumnMap[name]] = row[m2[name]];
+                for (const { name } of schema1.columns)updatedRow[combinedColumnMap[name]] = row[m1[name]];
+                newTable.updateRow(updatedRow);
+            }
+        });
+        table1.on("delete", (key)=>{
+            const row = newTable.findByKey(key);
+            if (row) {
+                const value = String(row[combinedColumnMap[joinColumn]]);
+                const keys = joinedKeys.get(value);
+                keys?.delete(key);
+                if (keys?.size === 0) joinedKeys.delete(value);
+                newTable.delete(key);
+            }
+        });
+        table2.on("update", (row)=>{
+            const keyValue = String(row[k2]);
+            for (const key of joinedKeys.get(keyValue) ?? []){
+                const targetRow = newTable.findByKey(key);
+                if (!targetRow) continue;
+                const updatedRow = targetRow.slice();
+                for (const { name } of table2.schema.columns)if (!(name in m1)) {
+                    if (row[m2[name]] !== updatedRow[combinedColumnMap[name]]) updatedRow[combinedColumnMap[name]] = row[m2[name]];
+                }
                 newTable.updateRow(updatedRow);
             }
         });
+        newTable.update = (key, columnName, value)=>{
+            const row = newTable.findByKey(key);
+            if (!row) throw Error(`[TableContainer] join row ${key} not found`);
+            if (columnName === schema1.key || columnName === joinColumn) throw Error(`[TableContainer] cannot edit join key ${columnName}`);
+            if (columnName in m1) table1.update(key, columnName, value);
+            else if (columnName in m2) table2.update(String(row[combinedColumnMap[schema2.key]]), columnName, value);
+            else throw Error(`[TableContainer] unknown join column ${columnName}`);
+        };
         this.addTable(newTable);
         return newTable;
     }

package/src/core/user/CurrentUser.js

@@ -0,0 +1,13 @@
+const DEFAULT_USER = {
+    name: "user",
+    authorizations: []
+};
+let currentUser = DEFAULT_USER;
+const getCurrentUser = ()=>currentUser;
+const setCurrentUser = (user)=>{
+    currentUser = void 0 === user ? DEFAULT_USER : "string" == typeof user ? {
+        name: user,
+        authorizations: []
+    } : user;
+};
+export { getCurrentUser, setCurrentUser };

package/src/index.js

@@ -1,12 +1,19 @@
 export * from "./ArrayProxy.js";
+export * from "./core/filter/PermissionFilter.js";
+export * from "./core/filter/PermissionFilteredTable.js";
 export * from "./core/module/VuuModule.js";
+export * from "./core/user/CurrentUser.js";
 export * from "./local-datasource-provider/LocalDatasourceProvider.js";
 export * from "./makeSuggestions.js";
+export * from "./notifications/index.js";
 export * from "./schemas.js";
 export * from "./simul/index.js";
 export * from "./basket/index.js";
+export * from "./module-admin/index.js";
+export * from "./user-admin/index.js";
 export * from "./test/index.js";
 export * from "./TickingArrayDataSource.js";
 export * from "./vuu-row-generator.js";
+export { ensureVuuModule } from "./core/module/ModuleContainer.js";
 export { default as tableContainer } from "./core/table/TableContainer.js";
 export { Table, buildDataColumnMap, buildDataColumnMapFromSchema } from "./Table.js";

package/src/local-datasource-provider/LocalDatasourceProvider.js

@@ -1,46 +1,70 @@
 import { jsx } from "react/jsx-runtime";
-import { DataProvider } from "@vuu-ui/vuu-utils";
-import ModuleContainer from "../core/module/ModuleContainer.js";
-import TableContainer from "../core/table/TableContainer.js";
-const serverAPI = {
-    getTableList: async ()=>{
-        const tables = ModuleContainer.moduleNames.reduce((tableList, moduleName)=>{
-            const moduleTables = ModuleContainer.get(moduleName).getTableList();
-            moduleTables.forEach((tableName)=>{
-                const table = TableContainer.getTable(tableName);
-                tableList.push(table.schema.table);
-            });
-            return tableList;
-        }, []);
-        return {
-            tables
-        };
-    },
-    getTableSchema: async ({ module, table })=>ModuleContainer.get(module).getTableSchema(table),
-    rpcCall: async ()=>{
-        throw Error("RpcCall no longer supported on LocalDataSourceProvider ServerAPI");
+import { DataProvider } from "@vuu-ui/core";
+import { DataProvider as vuu_utils_DataProvider } from "@vuu-ui/vuu-utils";
+import ModuleContainer, { ensureVuuModule } from "../core/module/ModuleContainer.js";
+const createLocalDataSourceProvider = (modules)=>{
+    const ownModules = modules ? new Map(modules.map((module)=>[
+            module.name,
+            module
+        ])) : void 0;
+    const getModule = (moduleName)=>{
+        if (ownModules) {
+            const module = ownModules.get(moduleName);
+            if (module) return module;
+            throw Error(`[LocalDataSourceProvider] module ${moduleName} is not available on this server`);
+        }
+        return ModuleContainer.get(moduleName);
+    };
+    const serverAPI = {
+        getTableList: async ()=>{
+            const tables = [];
+            for (const moduleName of ownModules?.keys() ?? ModuleContainer.moduleNames){
+                const module = getModule(moduleName);
+                for (const tableName of module.getTableList())tables.push(module.getTableSchema(tableName).table);
+            }
+            return {
+                tables
+            };
+        },
+        getTableSchema: async ({ module, table })=>getModule(module).getTableSchema(table),
+        rpcCall: async ()=>{
+            throw Error("RpcCall no longer supported on LocalDataSourceProvider ServerAPI");
+        }
+    };
+    const getServerAPI = async ()=>serverAPI;
+    class VuuDataSource {
+        constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
+            const config = {
+                aggregations,
+                baseFilterSpec,
+                columns,
+                filterSpec,
+                groupBy,
+                session,
+                sort,
+                visualLink
+            };
+            const module = getModule(table.module);
+            return module.createDataSource(table.table, viewport, config);
+        }
     }
+    const DataSourceProvider = ({ children })=>/*#__PURE__*/ jsx(vuu_utils_DataProvider, {
+            VuuDataSource: VuuDataSource,
+            getServerAPI: getServerAPI,
+            children: /*#__PURE__*/ jsx(DataProvider, {
+                VuuDataSource: VuuDataSource,
+                getServerAPI: getServerAPI,
+                children: children
+            })
+        });
+    return DataSourceProvider;
 };
-const getServerAPI = async ()=>serverAPI;
-class VuuDataSource {
-    constructor({ aggregations, baseFilterSpec, columns, filterSpec, groupBy, session, sort, table, viewport, visualLink }){
-        const config = {
-            aggregations,
-            baseFilterSpec,
-            columns,
-            filterSpec,
-            groupBy,
-            session,
-            sort,
-            visualLink
-        };
-        const module = ModuleContainer.get(table.module);
-        return module.createDataSource(table.table, viewport, config);
-    }
-}
-const LocalDataSourceProvider = ({ children })=>/*#__PURE__*/ jsx(DataProvider, {
-        VuuDataSource: VuuDataSource,
-        getServerAPI: getServerAPI,
-        children: children
-    });
-export { LocalDataSourceProvider };
+const LocalDataSourceProvider = createLocalDataSourceProvider();
+const createLocalVuuServer = ({ connectionId, modules })=>{
+    modules.forEach(ensureVuuModule);
+    return {
+        connectionId,
+        DataSourceProvider: createLocalDataSourceProvider(modules)
+    };
+};
+export { LocalDataSourceProvider, createLocalVuuServer };