remult 0.14.2 → 0.14.5

package/server/index.js

@@ -1,11 +1,4 @@
-"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; } });
+export { JsonEntityFileStorage } from './JsonEntityFileStorage';
+export { SiteArea } from './expressBridge';
+export { registerEntitiesOnServer } from './register-entities-on-server';
+export { registerActionsOnServer } from './register-actions-on-server';

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

@@ -1,50 +1,24 @@
-"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];
+import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
+export function registerActionsOnServer(area, controllers) {
+    var addAction = (a) => {
+        let x = a[serverActionField];
         if (!x) {
             throw 'failed to set server action, did you forget the BackendMethod Decorator?';
         }
         area.addAction(x);
     };
-    server_action_1.actionInfo.runningOnServer = true;
+    actionInfo.runningOnServer = true;
     if (controllers && controllers.length > 0) {
-        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; }
+        for (const c of controllers) {
+            let z = c[classBackendMethodsArray];
+            if (z)
+                for (const a of z) {
+                    addAction(a);
+                }
         }
     }
     else
-        server_action_1.actionInfo.allActions.forEach(function (a) {
+        actionInfo.allActions.forEach((a) => {
             addAction(a);
         });
 }
-exports.registerActionsOnServer = registerActionsOnServer;

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

@@ -1,19 +1,15 @@
-"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) {
+import { getEntityKey } from "../src/remult3";
+import { allEntities } from "../src/context";
+import { DataApi } from "../src/data-api";
+export function registerEntitiesOnServer(area, entities) {
     if (!entities)
-        entities = context_1.allEntities;
+        entities = allEntities;
     //add Api Entries
-    entities.forEach(function (e) {
-        var key = remult3_1.getEntityKey(e);
+    entities.forEach(e => {
+        let key = getEntityKey(e);
         if (key != undefined)
-            area.add(key, function (c) {
-                return new data_api_1.DataApi(c.repo(e), c);
+            area.add(key, c => {
+                return new DataApi(c.repo(e), c);
             });
     });
 }
-exports.registerEntitiesOnServer = registerEntitiesOnServer;

package/src/__EntityValueProvider.js

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

package/src/__RowsOfDataForTesting.js

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

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

@@ -1,72 +1,38 @@
-"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();
+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();
 function testKnexSqlImpl(knex, name) {
-    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*/];
+    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;
                 }
             });
-        }); }, focus);
+        }, focus);
     };
 }
-exports.testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
+export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
     client: 'pg',
     connection: process.env.DATABASE_URL,
 }), "postgres");
-db_tests_setup_1.addDatabaseToTest(exports.testKnexPGSqlImpl);
+addDatabaseToTest(testKnexPGSqlImpl);
 if (process.env['TESTS_SQL_SERVER'])
-    db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
         client: 'mssql',
         connection: {
             server: '127.0.0.1',
@@ -81,151 +47,67 @@ if (process.env['TESTS_SQL_SERVER'])
         } //,debug: true
     }), "sql server"));
 if (true)
-    db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
         client: 'better-sqlite3',
         connection: {
             filename: ":memory:"
         },
     }), "sqlite3"));
-var pg = postgres_1.createPostgresConnection({
+let pg = createPostgresConnection({
     autoCreateTables: false
 });
-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*/];
+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;
             }
         });
-    }); }, focus);
+    }, focus);
 }
-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*/];
-            }
-        });
+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);
     });
 });
-var client = new mongodb_1.MongoClient("mongodb://localhost:27017/local");
-var done;
-var mongoDbPromise = client.connect().then(function (c) {
+let client = new MongoClient("mongodb://localhost:27017/local");
+let done;
+let mongoDbPromise = client.connect().then(c => {
     done = c;
     return c.db("test");
 });
-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*/];
+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;
             }
         });
-    }); }, focus);
+    }, focus);
 }
-exports.testMongo = testMongo;
-db_tests_setup_1.addDatabaseToTest(testMongo);
-require("../shared-tests");
+addDatabaseToTest(testMongo);
+import '../shared-tests';

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

@@ -1,118 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var __1 = require("../..");
-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");
-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: __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*/];
-            }
-        });
-    });
+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);
 }, false);
-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: [
-                                    __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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);

package/src/column-interfaces.js

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