remult 0.14.6 → 0.14.7

package/server/index.js

@@ -1,4 +1,11 @@
-export { JsonEntityFileStorage } from './JsonEntityFileStorage';
-export { SiteArea } from './expressBridge';
-export { registerEntitiesOnServer } from './register-entities-on-server';
-export { registerActionsOnServer } from './register-actions-on-server';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerActionsOnServer = exports.registerEntitiesOnServer = exports.SiteArea = exports.JsonEntityFileStorage = void 0;
+var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
+Object.defineProperty(exports, "JsonEntityFileStorage", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonEntityFileStorage; } });
+var expressBridge_1 = require("./expressBridge");
+Object.defineProperty(exports, "SiteArea", { enumerable: true, get: function () { return expressBridge_1.SiteArea; } });
+var register_entities_on_server_1 = require("./register-entities-on-server");
+Object.defineProperty(exports, "registerEntitiesOnServer", { enumerable: true, get: function () { return register_entities_on_server_1.registerEntitiesOnServer; } });
+var register_actions_on_server_1 = require("./register-actions-on-server");
+Object.defineProperty(exports, "registerActionsOnServer", { enumerable: true, get: function () { return register_actions_on_server_1.registerActionsOnServer; } });

package/server/register-actions-on-server.js

@@ -1,24 +1,50 @@
-import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
-export function registerActionsOnServer(area, controllers) {
-    var addAction = (a) => {
-        let x = a[serverActionField];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerActionsOnServer = void 0;
+var tslib_1 = require("tslib");
+var server_action_1 = require("../src/server-action");
+function registerActionsOnServer(area, controllers) {
+    var e_1, _a, e_2, _b;
+    var addAction = function (a) {
+        var x = a[server_action_1.serverActionField];
         if (!x) {
             throw 'failed to set server action, did you forget the BackendMethod Decorator?';
         }
         area.addAction(x);
     };
-    actionInfo.runningOnServer = true;
+    server_action_1.actionInfo.runningOnServer = true;
     if (controllers && controllers.length > 0) {
-        for (const c of controllers) {
-            let z = c[classBackendMethodsArray];
-            if (z)
-                for (const a of z) {
-                    addAction(a);
-                }
+        try {
+            for (var controllers_1 = tslib_1.__values(controllers), controllers_1_1 = controllers_1.next(); !controllers_1_1.done; controllers_1_1 = controllers_1.next()) {
+                var c = controllers_1_1.value;
+                var z = c[server_action_1.classBackendMethodsArray];
+                if (z)
+                    try {
+                        for (var z_1 = (e_2 = void 0, tslib_1.__values(z)), z_1_1 = z_1.next(); !z_1_1.done; z_1_1 = z_1.next()) {
+                            var a = z_1_1.value;
+                            addAction(a);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (z_1_1 && !z_1_1.done && (_b = z_1.return)) _b.call(z_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (controllers_1_1 && !controllers_1_1.done && (_a = controllers_1.return)) _a.call(controllers_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     else
-        actionInfo.allActions.forEach((a) => {
+        server_action_1.actionInfo.allActions.forEach(function (a) {
             addAction(a);
         });
 }
+exports.registerActionsOnServer = registerActionsOnServer;

package/server/register-entities-on-server.js

@@ -1,15 +1,19 @@
-import { getEntityKey } from "../src/remult3";
-import { allEntities } from "../src/context";
-import { DataApi } from "../src/data-api";
-export function registerEntitiesOnServer(area, entities) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEntitiesOnServer = void 0;
+var remult3_1 = require("../src/remult3");
+var context_1 = require("../src/context");
+var data_api_1 = require("../src/data-api");
+function registerEntitiesOnServer(area, entities) {
     if (!entities)
-        entities = allEntities;
+        entities = context_1.allEntities;
     //add Api Entries
-    entities.forEach(e => {
-        let key = getEntityKey(e);
+    entities.forEach(function (e) {
+        var key = remult3_1.getEntityKey(e);
         if (key != undefined)
-            area.add(key, c => {
-                return new DataApi(c.repo(e), c);
+            area.add(key, function (c) {
+                return new data_api_1.DataApi(c.repo(e), c);
             });
     });
 }
+exports.registerEntitiesOnServer = registerEntitiesOnServer;

package/src/__EntityValueProvider.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/__RowsOfDataForTesting.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -1,38 +1,72 @@
-import { Remult } from "../context";
-import { KnexDataProvider, KnexSchemaBuilder } from '../../remult-knex';
-import * as Knex from 'knex';
-import { MongoClient } from 'mongodb';
-import { config } from 'dotenv';
-import { createPostgresConnection, PostgresSchemaBuilder } from "../../postgres";
-import { addDatabaseToTest, itWithFocus, testAll } from "../shared-tests/db-tests-setup";
-config();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMongo = exports.testPostgresImplementation = exports.testKnexPGSqlImpl = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../context");
+var remult_knex_1 = require("../../remult-knex");
+var Knex = require("knex");
+var mongodb_1 = require("mongodb");
+var dotenv_1 = require("dotenv");
+var postgres_1 = require("../../postgres");
+var db_tests_setup_1 = require("../shared-tests/db-tests-setup");
+dotenv_1.config();
 function testKnexSqlImpl(knex, name) {
-    return (key, what, focus = false) => {
-        itWithFocus(key + " " + name + " - knex", async () => {
-            let db = new KnexDataProvider(knex);
-            let remult = new Remult(db);
-            await what({
-                db, remult,
-                createEntity: async (entity) => {
-                    let repo = remult.repo(entity);
-                    let sb = new KnexSchemaBuilder(knex);
-                    await knex.schema.dropTableIfExists(await repo.metadata.getDbName());
-                    await sb.createIfNotExist(repo.metadata);
-                    await sb.verifyAllColumns(repo.metadata);
-                    await knex(await repo.metadata.getDbName()).delete();
-                    return repo;
+    var _this = this;
+    return function (key, what, focus) {
+        if (focus === void 0) { focus = false; }
+        db_tests_setup_1.itWithFocus(key + " " + name + " - knex", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var db, remult;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        db = new remult_knex_1.KnexDataProvider(knex);
+                        remult = new context_1.Remult(db);
+                        return [4 /*yield*/, what({
+                                db: db, remult: remult,
+                                createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var repo, sb, _a, _b, _c;
+                                    return tslib_1.__generator(this, function (_d) {
+                                        switch (_d.label) {
+                                            case 0:
+                                                repo = remult.repo(entity);
+                                                sb = new remult_knex_1.KnexSchemaBuilder(knex);
+                                                _b = (_a = knex.schema).dropTableIfExists;
+                                                return [4 /*yield*/, repo.metadata.getDbName()];
+                                            case 1: return [4 /*yield*/, _b.apply(_a, [_d.sent()])];
+                                            case 2:
+                                                _d.sent();
+                                                return [4 /*yield*/, sb.createIfNotExist(repo.metadata)];
+                                            case 3:
+                                                _d.sent();
+                                                return [4 /*yield*/, sb.verifyAllColumns(repo.metadata)];
+                                            case 4:
+                                                _d.sent();
+                                                _c = knex;
+                                                return [4 /*yield*/, repo.metadata.getDbName()];
+                                            case 5: return [4 /*yield*/, _c.apply(void 0, [_d.sent()]).delete()];
+                                            case 6:
+                                                _d.sent();
+                                                return [2 /*return*/, repo];
+                                        }
+                                    });
+                                }); }
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
-        }, focus);
+        }); }, focus);
     };
 }
-export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
+exports.testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
     client: 'pg',
     connection: process.env.DATABASE_URL,
 }), "postgres");
-addDatabaseToTest(testKnexPGSqlImpl);
+db_tests_setup_1.addDatabaseToTest(exports.testKnexPGSqlImpl);
 if (process.env['TESTS_SQL_SERVER'])
-    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
         client: 'mssql',
         connection: {
             server: '127.0.0.1',
@@ -47,67 +81,151 @@ if (process.env['TESTS_SQL_SERVER'])
         } //,debug: true
     }), "sql server"));
 if (true)
-    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
         client: 'better-sqlite3',
         connection: {
             filename: ":memory:"
         },
     }), "sqlite3"));
-let pg = createPostgresConnection({
+var pg = postgres_1.createPostgresConnection({
     autoCreateTables: false
 });
-export function testPostgresImplementation(key, what, focus = false) {
-    itWithFocus(key + " - postgres", async () => {
-        let db = await pg;
-        let remult = new Remult(db);
-        await what({
-            db, remult,
-            createEntity: async (entity) => {
-                let repo = remult.repo(entity);
-                let sb = new PostgresSchemaBuilder(db);
-                await db.execute("drop table if exists " + await repo.metadata.getDbName());
-                await sb.createIfNotExist(repo.metadata);
-                await sb.verifyAllColumns(repo.metadata);
-                await db.execute("delete from " + await repo.metadata.getDbName());
-                return repo;
+function testPostgresImplementation(key, what, focus) {
+    var _this = this;
+    if (focus === void 0) { focus = false; }
+    db_tests_setup_1.itWithFocus(key + " - postgres", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var db, remult;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, pg];
+                case 1:
+                    db = _a.sent();
+                    remult = new context_1.Remult(db);
+                    return [4 /*yield*/, what({
+                            db: db, remult: remult,
+                            createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var repo, sb, _a, _b, _c, _d, _e, _f;
+                                return tslib_1.__generator(this, function (_g) {
+                                    switch (_g.label) {
+                                        case 0:
+                                            repo = remult.repo(entity);
+                                            sb = new postgres_1.PostgresSchemaBuilder(db);
+                                            _b = (_a = db).execute;
+                                            _c = "drop table if exists ";
+                                            return [4 /*yield*/, repo.metadata.getDbName()];
+                                        case 1: return [4 /*yield*/, _b.apply(_a, [_c + (_g.sent())])];
+                                        case 2:
+                                            _g.sent();
+                                            return [4 /*yield*/, sb.createIfNotExist(repo.metadata)];
+                                        case 3:
+                                            _g.sent();
+                                            return [4 /*yield*/, sb.verifyAllColumns(repo.metadata)];
+                                        case 4:
+                                            _g.sent();
+                                            _e = (_d = db).execute;
+                                            _f = "delete from ";
+                                            return [4 /*yield*/, repo.metadata.getDbName()];
+                                        case 5: return [4 /*yield*/, _e.apply(_d, [_f + (_g.sent())])];
+                                        case 6:
+                                            _g.sent();
+                                            return [2 /*return*/, repo];
+                                    }
+                                });
+                            }); }
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
             }
         });
-    }, focus);
+    }); }, focus);
 }
-addDatabaseToTest(testPostgresImplementation);
-import { Categories } from "../tests/remult-3-entities";
-import { MongoDataProvider } from "../../remult-mongo";
-testAll("transactions", async ({ db, createEntity }) => {
-    let x = await createEntity(Categories);
-    await db.transaction(async (db) => {
-        let remult = new Remult(db);
-        expect(await remult.repo(Categories).count()).toBe(0);
+exports.testPostgresImplementation = testPostgresImplementation;
+db_tests_setup_1.addDatabaseToTest(testPostgresImplementation);
+var remult_3_entities_1 = require("../tests/remult-3-entities");
+var remult_mongo_1 = require("../../remult-mongo");
+db_tests_setup_1.testAll("transactions", function (_a) {
+    var db = _a.db, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    x = _b.sent();
+                    return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            var remult, _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        remult = new context_1.Remult(db);
+                                        _a = expect;
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).count()];
+                                    case 1:
+                                        _a.apply(void 0, [_b.sent()]).toBe(0);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
     });
 });
-let client = new MongoClient("mongodb://localhost:27017/local");
-let done;
-let mongoDbPromise = client.connect().then(c => {
+var client = new mongodb_1.MongoClient("mongodb://localhost:27017/local");
+var done;
+var mongoDbPromise = client.connect().then(function (c) {
     done = c;
     return c.db("test");
 });
-afterAll(async () => {
-    if (done)
-        done.close();
-});
-export function testMongo(key, what, focus = false) {
-    itWithFocus(key + " - mongo", async () => {
-        let mongoDb = await mongoDbPromise;
-        let db = new MongoDataProvider(mongoDb, client);
-        let remult = new Remult(db);
-        await what({
-            db, remult,
-            createEntity: async (entity) => {
-                let repo = remult.repo(entity);
-                await mongoDb.collection(await repo.metadata.getDbName()).deleteMany({});
-                return repo;
+afterAll(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    return tslib_1.__generator(this, function (_a) {
+        if (done)
+            done.close();
+        return [2 /*return*/];
+    });
+}); });
+function testMongo(key, what, focus) {
+    var _this = this;
+    if (focus === void 0) { focus = false; }
+    db_tests_setup_1.itWithFocus(key + " - mongo", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var mongoDb, db, remult;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, mongoDbPromise];
+                case 1:
+                    mongoDb = _a.sent();
+                    db = new remult_mongo_1.MongoDataProvider(mongoDb, client);
+                    remult = new context_1.Remult(db);
+                    return [4 /*yield*/, what({
+                            db: db, remult: remult,
+                            createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var repo, _a, _b;
+                                return tslib_1.__generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            repo = remult.repo(entity);
+                                            _b = (_a = mongoDb).collection;
+                                            return [4 /*yield*/, repo.metadata.getDbName()];
+                                        case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent()]).deleteMany({})];
+                                        case 2:
+                                            _c.sent();
+                                            return [2 /*return*/, repo];
+                                    }
+                                });
+                            }); }
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
             }
         });
-    }, focus);
+    }); }, focus);
 }
-addDatabaseToTest(testMongo);
-import '../shared-tests';
+exports.testMongo = testMongo;
+db_tests_setup_1.addDatabaseToTest(testMongo);
+require("../shared-tests");

package/src/backend-tests/my-test.backend-spec.js

@@ -1,49 +1,118 @@
-import { SqlDatabase } from "../..";
-import { KnexDataProvider } from '../../remult-knex';
-import { config } from 'dotenv';
-import { testKnexPGSqlImpl, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
-import { entityWithValidations } from "../shared-tests/entityWithValidations";
-config();
-testPostgresImplementation("sql filter", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: SqlDatabase.customFilter(async (build) => {
-            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
-        })
-    })).length).toBe(2);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var remult_knex_1 = require("../../remult-knex");
+var dotenv_1 = require("dotenv");
+var backend_database_test_setup_backend_spec_1 = require("./backend-database-test-setup.backend-spec");
+var entityWithValidations_1 = require("../shared-tests/entityWithValidations");
+var sql_database_1 = require("../data-providers/sql-database");
+dotenv_1.config();
+backend_database_test_setup_backend_spec_1.testPostgresImplementation("sql filter", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: sql_database_1.SqlDatabase.customFilter(function (build) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                                    return [2 /*return*/];
+                                });
+                            }); })
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testPostgresImplementation("sql filter2", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: {
-            $or: [
-                SqlDatabase.customFilter(async (build) => {
-                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
-                }),
-                {
-                    myId: 2
-                }
-            ]
-        }
-    })).length).toBe(3);
+backend_database_test_setup_backend_spec_1.testPostgresImplementation("sql filter2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: {
+                                $or: [
+                                    sql_database_1.SqlDatabase.customFilter(function (build) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                        return tslib_1.__generator(this, function (_a) {
+                                            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                                            return [2 /*return*/];
+                                        });
+                                    }); }),
+                                    {
+                                        myId: 2
+                                    }
+                                ]
+                            }
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(3);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testKnexPGSqlImpl("knex filter", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: KnexDataProvider.customFilter(async () => {
-            return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
-        })
-    })).length).toBe(2);
+backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("knex filter", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: remult_knex_1.KnexDataProvider.customFilter(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    return [2 /*return*/, function (build) { return build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]); }];
+                                });
+                            }); })
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: {
-            $or: [KnexDataProvider.customFilter(async () => {
-                    return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
-                }), {
-                    myId: 4
-                }]
-        }
-    })).length).toBe(3);
+backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("knex filter2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: {
+                                $or: [remult_knex_1.KnexDataProvider.customFilter(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                        return tslib_1.__generator(this, function (_a) {
+                                            return [2 /*return*/, function (build) { return build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]); }];
+                                        });
+                                    }); }), {
+                                        myId: 4
+                                    }]
+                            }
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(3);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);

package/src/column-interfaces.js

@@ -1,7 +1,11 @@
-export function valueOrExpressionToValue(f) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueOrExpressionToValue = void 0;
+function valueOrExpressionToValue(f) {
     if (typeof f === 'function') {
-        let x = f;
+        var x = f;
         return x();
     }
     return f;
 }
+exports.valueOrExpressionToValue = valueOrExpressionToValue;