ballerina-core 1.0.261 → 1.0.264

package/bin/src/forms/domains/parser/domains/predicates/state.js

@@ -1,1062 +0,0 @@
-import { Map, Set, List, OrderedMap } from "immutable";
-import { ValueOrErrors, MapRepo, Updater, simpleUpdater, replaceWith, ListRepo, } from "../../../../../../main";
-const calculateVisibility = (expr, bindings) => {
-    if (typeof expr == "boolean") {
-        return ValueOrErrors.Default.return(expr);
-    }
-    return Expr.Operations.Evaluate(bindings)(expr).Then((result) => {
-        if (typeof result == "boolean") {
-            return ValueOrErrors.Default.return(result);
-        }
-        return ValueOrErrors.Default.throwOne(`Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`);
-    });
-};
-export const FieldPredicateExpression = {
-    Default: {
-        unit: (value) => ({ kind: "unit", value }),
-        primitive: (value) => ({
-            kind: "primitive",
-            value,
-        }),
-        record: (value, fields) => ({ kind: "record", value, fields }),
-        list: (value, elementExpression) => ({ kind: "list", value, elementExpression }),
-        map: (value, keyExpression, valueExpression) => ({
-            kind: "map",
-            value,
-            keyExpression,
-            valueExpression,
-        }),
-        tuple: (value, elementExpressions) => ({
-            kind: "tuple",
-            value,
-            elementExpressions,
-        }),
-        sum: (value, leftExpression, rightExpression) => ({
-            kind: "sum",
-            value,
-            leftExpression: leftExpression !== null && leftExpression !== void 0 ? leftExpression : FieldPredicateExpression.Default.unit(false),
-            rightExpression: rightExpression !== null && rightExpression !== void 0 ? rightExpression : FieldPredicateExpression.Default.unit(false),
-        }),
-    },
-};
-export const FormFieldPredicateEvaluation = {
-    Default: {
-        unit: (value) => ({
-            kind: "unit",
-            value,
-        }),
-        primitive: (value) => ({
-            kind: "primitive",
-            value,
-        }),
-        form: (value, fields) => ({ kind: "form", value, fields }),
-        list: (value, elementValues) => ({
-            kind: "list",
-            value,
-            elementValues,
-        }),
-        map: (value, elementValues) => ({ kind: "map", value, elementValues }),
-        tuple: (value, elementValues) => ({
-            kind: "tuple",
-            value,
-            elementValues,
-        }),
-        sum: (value, innerValue) => ({ kind: "sum", value, innerValue }),
-    },
-};
-export const ValueRecord = {
-    Default: {
-        empty: () => ({ kind: "record", fields: OrderedMap() }),
-        fromJSON: (json) => ({
-            kind: "record",
-            fields: OrderedMap(Object.assign({}, json)), // TODO - check this works ok
-        }),
-        fromMap: (map) => ({
-            kind: "record",
-            fields: OrderedMap(map),
-        }),
-    },
-    Operations: {
-        has: (record, key) => {
-            return record.fields.has(key);
-        },
-    },
-    Updaters: Object.assign(Object.assign({}, simpleUpdater()("fields")), { update: (key, updater) => {
-            return ValueRecord.Updaters.fields(MapRepo.Updaters.update(key, updater));
-        }, set: (key, value) => {
-            return ValueRecord.Updaters.fields(MapRepo.Updaters.set(key, value));
-        }, remove: (key) => {
-            return ValueRecord.Updaters.fields(MapRepo.Updaters.remove(key));
-        }, clear: () => {
-            return ValueRecord.Updaters.fields(replaceWith(OrderedMap()));
-        } }),
-};
-export const ValueUnionCase = {
-    Default: (caseName, fields) => ({
-        kind: "unionCase",
-        caseName,
-        fields,
-    }),
-    Updaters: Object.assign({ case: (caseName) => (upd) => Updater((v) => ValueUnionCase.Default(caseName, upd(v.fields))) }, simpleUpdater()("fields")),
-};
-export const ValueUnit = {
-    Default: () => ({ kind: "unit" }),
-};
-export const ValueOption = {
-    Default: {
-        some: (value) => ({
-            kind: "option",
-            isSome: true,
-            value,
-        }),
-        none: () => ({
-            kind: "option",
-            isSome: false,
-            value: { kind: "unit" },
-        }),
-    },
-    Updaters: {
-        value: (_) => Updater((v) => ValueOption.Default.some(_(v))),
-    },
-};
-export const ValueSum = {
-    Default: (value) => ({
-        kind: "sum",
-        value,
-    }),
-    Updaters: Object.assign({}, simpleUpdater()("value")),
-};
-export const ValueSumN = {
-    Default: (caseIndex, arity, value) => ({
-        kind: "sumN",
-        caseIndex,
-        arity,
-        value,
-    }),
-    Updaters: Object.assign({ case: (caseIndex) => (upd) => Updater((v) => ValueSumN.Default(caseIndex, v.arity, upd(v.value))) }, simpleUpdater()("value")),
-};
-export const ValueTuple = {
-    Default: () => ({
-        kind: "tuple",
-        values: List(),
-    }),
-    Updaters: Object.assign({}, simpleUpdater()("values")),
-};
-export const ValueReadOnly = {
-    Default: (value) => ({
-        kind: "readOnly",
-        ReadOnly: value,
-    }),
-    Updaters: Object.assign({}, simpleUpdater()("ReadOnly")),
-};
-export const ValueTable = {
-    Default: {
-        empty: () => ({
-            kind: "table",
-            from: 0,
-            to: 0,
-            data: OrderedMap(),
-            hasMoreValues: false,
-        }),
-        fromParsed: (from, to, hasMoreValues, data) => ({
-            kind: "table",
-            from,
-            to,
-            data,
-            hasMoreValues,
-        }),
-    },
-    Updaters: Object.assign({}, simpleUpdater()("data")),
-};
-export const ValueFilterContains = {
-    Default: (contains) => ({
-        kind: "contains",
-        contains,
-    }),
-};
-export const ValueFilterEqualsTo = {
-    Default: (equalsTo) => ({
-        kind: "=",
-        equalsTo,
-    }),
-};
-export const ValueFilterNotEqualsTo = {
-    Default: (notEqualsTo) => ({
-        kind: "!=",
-        notEqualsTo,
-    }),
-};
-export const ValueFilterGreaterThanOrEqualsTo = {
-    Default: (greaterThanOrEqualsTo) => ({
-        kind: ">=",
-        greaterThanOrEqualsTo,
-    }),
-};
-export const ValueFilterGreaterThan = {
-    Default: (greaterThan) => ({
-        kind: ">",
-        greaterThan,
-    }),
-};
-export const ValueFilterIsNotNull = {
-    Default: () => ({
-        kind: "!=null",
-    }),
-};
-export const ValueFilterIsNull = {
-    Default: () => ({
-        kind: "=null",
-    }),
-};
-export const ValueFilterSmallerThanOrEqualsTo = {
-    Default: (smallerThanOrEqualsTo) => ({
-        kind: "<=",
-        smallerThanOrEqualsTo,
-    }),
-};
-export const ValueFilterSmallerThan = {
-    Default: (smallerThan) => ({
-        kind: "<",
-        smallerThan,
-    }),
-};
-export const ValueFilterStartsWith = {
-    Default: (startsWith) => ({
-        kind: "startsWith",
-        startsWith,
-    }),
-};
-export const BinaryOperators = ["or", "equals"];
-export const BinaryOperatorsSet = Set(BinaryOperators);
-const defaultPredicateDate = () => {
-    const d = new Date();
-    d.setUTCHours(0, 0, 0, 0);
-    return d;
-};
-export const PredicateValue = {
-    Default: {
-        string: () => "",
-        number: () => 0,
-        boolean: () => false,
-        date: () => defaultPredicateDate(),
-        unit: () => ({ kind: "unit" }),
-        tuple: (values) => ({
-            kind: "tuple",
-            values,
-        }),
-        record: (fields) => ({
-            kind: "record",
-            fields,
-        }),
-        unionCase: (caseName, fields) => ({
-            kind: "unionCase",
-            caseName,
-            fields,
-        }),
-        option: (isSome, value) => ({
-            kind: "option",
-            isSome,
-            value,
-        }),
-        varLookup: (varName) => ({
-            kind: "varLookup",
-            varName,
-        }),
-        sum: (value) => ({
-            kind: "sum",
-            value,
-        }),
-        sumN: (caseIndex, arity, value) => ({
-            kind: "sumN",
-            caseIndex,
-            arity,
-            value,
-        }),
-        table: (from, to, data, hasMoreValues) => ({
-            kind: "table",
-            from,
-            to,
-            data,
-            hasMoreValues,
-        }),
-        readonly: (value) => ({
-            kind: "readOnly",
-            ReadOnly: value,
-        }),
-        filterContains: (contains) => ({
-            kind: "contains",
-            contains,
-        }),
-        filterEqualsTo: (equalsTo) => ({
-            kind: "=",
-            equalsTo,
-        }),
-        filterNotEqualsTo: (notEqualsTo) => ({
-            kind: "!=",
-            notEqualsTo,
-        }),
-        filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
-            kind: ">=",
-            greaterThanOrEqualsTo,
-        }),
-        filterGreaterThan: (greaterThan) => ({
-            kind: ">",
-            greaterThan,
-        }),
-        filterIsNotNull: () => ({
-            kind: "!=null",
-        }),
-        filterIsNull: () => ({
-            kind: "=null",
-        }),
-        filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
-            kind: "<=",
-            smallerThanOrEqualsTo,
-        }),
-        filterSmallerThan: (smallerThan) => ({
-            kind: "<",
-            smallerThan,
-        }),
-        filterStartsWith: (startsWith) => ({
-            kind: "startsWith",
-            startsWith,
-        }),
-    },
-    Operations: {
-        GetKind: (value) => typeof value == "object"
-            ? "kind" in value
-                ? ValueOrErrors.Default.return(value.kind)
-                : PredicateValue.Operations.IsDate(value)
-                    ? ValueOrErrors.Default.return("date")
-                    : ValueOrErrors.Default.throwOne("invalid")
-            : ValueOrErrors.Default.return(typeof value),
-        IsPrimitive: (value) => {
-            return (PredicateValue.Operations.IsBoolean(value) ||
-                PredicateValue.Operations.IsNumber(value) ||
-                PredicateValue.Operations.IsString(value) ||
-                PredicateValue.Operations.IsDate(value));
-        },
-        IsBoolean: (value) => {
-            return typeof value == "boolean";
-        },
-        IsNumber: (value) => {
-            return typeof value == "number";
-        },
-        IsString: (value) => {
-            return typeof value == "string";
-        },
-        IsDate: (value) => {
-            return (typeof value == "object" &&
-                Object.prototype.toString.call(value) === "[object Date]" &&
-                value instanceof Date &&
-                !isNaN(value.getTime()));
-        },
-        IsUnit: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "unit");
-        },
-        IsUnionCase: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "unionCase");
-        },
-        IsRecord: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "record");
-        },
-        IsTuple: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "tuple");
-        },
-        IsOption: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "option");
-        },
-        IsTable: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "table");
-        },
-        IsSum: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "sum");
-        },
-        IsSumN: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "sumN");
-        },
-        IsVarLookup: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "varLookup");
-        },
-        IsCustom: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "custom");
-        },
-        IsReadOnly: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "readOnly");
-        },
-        IsFilterContains: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "contains");
-        },
-        IsFilterEqualsTo: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "=");
-        },
-        IsFilterNotEqualsTo: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "!=");
-        },
-        IsFilterGreaterThanOrEqualsTo: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == ">=");
-        },
-        IsFilterGreaterThan: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == ">");
-        },
-        IsFilterIsNotNull: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "!=null");
-        },
-        IsFilterIsNull: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "=null");
-        },
-        IsFilterSmallerThanOrEqualsTo: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "<=");
-        },
-        IsFilterSmallerThan: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "<");
-        },
-        IsFilterStartsWith: (value) => {
-            return (typeof value == "object" &&
-                !PredicateValue.Operations.IsDate(value) &&
-                value.kind == "startsWith");
-        },
-        KindAndValueToFilter: (kind, value) => {
-            switch (kind) {
-                case "contains":
-                    return PredicateValue.Default.filterContains(value);
-                case "=":
-                    return PredicateValue.Default.filterEqualsTo(value);
-                case "!=":
-                    return PredicateValue.Default.filterNotEqualsTo(value);
-                case ">=":
-                    return PredicateValue.Default.filterGreaterThanOrEqualsTo(value);
-                case ">":
-                    return PredicateValue.Default.filterGreaterThan(value);
-                case "!=null":
-                    return PredicateValue.Default.filterIsNotNull();
-                case "=null":
-                    return PredicateValue.Default.filterIsNull();
-                case "<=":
-                    return PredicateValue.Default.filterSmallerThanOrEqualsTo(value);
-                case "<":
-                    return PredicateValue.Default.filterSmallerThan(value);
-                case "startsWith":
-                    return PredicateValue.Default.filterStartsWith(value);
-                default:
-                    return PredicateValue.Default.filterEqualsTo(value);
-            }
-        },
-        FilterToKindAndValue: (filter) => {
-            switch (filter.kind) {
-                case "contains":
-                    return { kind: "contains", value: filter.contains };
-                case "=":
-                    return { kind: "=", value: filter.equalsTo };
-                case "!=":
-                    return { kind: "!=", value: filter.notEqualsTo };
-                case ">=":
-                    return { kind: ">=", value: filter.greaterThanOrEqualsTo };
-                case ">":
-                    return { kind: ">", value: filter.greaterThan };
-                case "!=null":
-                    return { kind: "!=null", value: PredicateValue.Default.unit() };
-                case "=null":
-                    return { kind: "=null", value: PredicateValue.Default.unit() };
-                case "<=":
-                    return { kind: "<=", value: filter.smallerThanOrEqualsTo };
-                case "<":
-                    return { kind: "<", value: filter.smallerThan };
-                default:
-                    return { kind: "startsWith", value: filter.startsWith };
-            }
-        },
-        ParseAsDate: (json) => {
-            if (PredicateValue.Operations.IsDate(json))
-                return ValueOrErrors.Default.return(json);
-            return ValueOrErrors.Default.throwOne(`date has invalid value property`);
-        },
-        ParseAsVarLookup: (json) => {
-            if (json.kind == "varLookup" && typeof json.varName == "string")
-                return ValueOrErrors.Default.return(PredicateValue.Default.varLookup(json.varName));
-            return ValueOrErrors.Default.throwOne(`varLookup has invalid varName property`);
-        },
-        ParseAsUnionCase: (json) => {
-            if (typeof json.caseName == "string")
-                return ValueOrErrors.Default.return(PredicateValue.Default.unionCase(json.caseName, json.value));
-            return ValueOrErrors.Default.throwOne(`union case has invalid caseName property`);
-        },
-        ParseAsRecord: (json, types) => {
-            if ("fields" in json && typeof json.fields == "object") {
-                return ValueOrErrors.Operations.All(List(Object.entries(json.fields).map(([fieldName, fieldValue]) => PredicateValue.Operations.parse(fieldValue, { kind: "expression" }, types).Then((value) => ValueOrErrors.Default.return([fieldName, value]))))).Then((entries) => ValueOrErrors.Default.return(PredicateValue.Default.record(OrderedMap(entries))));
-            }
-            return ValueOrErrors.Default.throwOne(`record has no field property`);
-        },
-        ParseAsTuple: (json, types) => {
-            if (json.values != undefined && Array.isArray(json.values)) {
-                return ValueOrErrors.Operations.All(List(json.values.map((elementValue) => PredicateValue.Operations.parse(elementValue, { kind: "expression" }, types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
-            }
-            return ValueOrErrors.Default.throwOne(`Error: tuple has no values property`);
-        },
-        // TODO -- do we need to add table here ?
-        parse: (json, type, types) => {
-            const result = (() => {
-                if (type.kind == "expression" &&
-                    (typeof json == "boolean" ||
-                        typeof json == "number" ||
-                        typeof json == "string"))
-                    return ValueOrErrors.Default.return(json);
-                if (type.kind == "expression" && json.kind == undefined) {
-                    return ValueOrErrors.Default.throwOne(`evaluation statement has no kind value`);
-                }
-                if (type.kind == "expression" && json.kind == "guid") {
-                    return ValueOrErrors.Default.return(json);
-                }
-                if (type.kind == "expression" && json.kind == "date") {
-                    return PredicateValue.Operations.ParseAsDate(json);
-                }
-                if (type.kind == "expression" && json.kind == "unit") {
-                    return ValueOrErrors.Default.return(PredicateValue.Default.unit());
-                }
-                if (type.kind == "expression" && json.kind == "varLookup") {
-                    return PredicateValue.Operations.ParseAsVarLookup(json);
-                }
-                if (type.kind == "expression" &&
-                    json.kind == "record" &&
-                    "caseName" in json) {
-                    return PredicateValue.Operations.ParseAsUnionCase(json);
-                }
-                if (type.kind == "expression" &&
-                    json.kind == "record" &&
-                    "fields" in json) {
-                    return PredicateValue.Operations.ParseAsRecord(json, types);
-                }
-                if (type.kind == "expression" &&
-                    json.kind == "tuple" &&
-                    "values" in json) {
-                    return PredicateValue.Operations.ParseAsTuple(json, types);
-                }
-                if (type.kind == "primitive" && type.value == "Date") {
-                    if (PredicateValue.Operations.IsDate(json)) {
-                        return ValueOrErrors.Default.return(json);
-                    }
-                    return ValueOrErrors.Default.throwOne(`failed to parse date ${JSON.stringify(json)}`);
-                }
-                if (type.kind == "primitive" && type.value == "maybeBoolean") {
-                    return json == undefined
-                        ? ValueOrErrors.Default.return(false)
-                        : ValueOrErrors.Default.return(json);
-                }
-                if (type.kind == "primitive") {
-                    return ValueOrErrors.Default.return(json);
-                }
-                if (type.kind == "lookup") {
-                    const subType = types.get(type.name);
-                    if (subType == undefined) {
-                        return ValueOrErrors.Default.throwOne(`cannot find field ${type.name} in types`);
-                    }
-                    return PredicateValue.Operations.parse(json, subType, types);
-                }
-                if (type.kind == "union") {
-                    const unionCase = type.args.get(json);
-                    if (unionCase == undefined) {
-                        return ValueOrErrors.Default.throwOne(`Error: cannot find union case ${JSON.stringify(json)} in types`);
-                    }
-                    return PredicateValue.Operations.ParseAsUnionCase({
-                        kind: "unionCase",
-                        caseName: json,
-                        value: { kind: "form", value: Map() },
-                    });
-                }
-                if (type.kind == "application" && type.value == "List") {
-                    return ValueOrErrors.Operations.All(List(json.map((elementValue) => PredicateValue.Operations.parse(elementValue, type.args[0], types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
-                }
-                if (type.kind == "application" && type.value == "Map") {
-                    return ValueOrErrors.Operations.All(List(json.map((keyValue) => PredicateValue.Operations.parse(keyValue.key, type.args[0], types).Then((key) => PredicateValue.Operations.parse(keyValue.value, type === null || type === void 0 ? void 0 : type.args[1], types).Then((value) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(List([key, value])))))))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
-                }
-                if (type.kind == "application" && type.value == "Sum") {
-                    return PredicateValue.Operations.parse(json.left, type === null || type === void 0 ? void 0 : type.args[0], types).Then((left) => PredicateValue.Operations.parse(json.right, type === null || type === void 0 ? void 0 : type.args[1], types).Then((right) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(List([left, right])))));
-                }
-                if (type.kind == "application" && type.value == "SingleSelection") {
-                    ValueOrErrors.Default.return(PredicateValue.Default.option(json["IsSome"], json["Value"]));
-                }
-                if (type.kind == "application" && type.value == "MultiSelection") {
-                    return ValueOrErrors.Operations.All(List(json.map((elementValue) => PredicateValue.Operations.parse(elementValue, type.args[0], types)))).Then((values) => ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)));
-                }
-                if (type.kind == "record") {
-                    return ValueOrErrors.Operations.All(List(Object.entries(json).map(([fieldName, fieldValue]) => {
-                        const subType = type.fields.get(fieldName);
-                        if (subType == undefined) {
-                            return ValueOrErrors.Default.throwOne(`cannot find field ${fieldName} in type ${JSON.stringify(type)}`);
-                        }
-                        return PredicateValue.Operations.parse(fieldValue, subType, types).Then((value) => ValueOrErrors.Default.return([fieldName, value]));
-                    }))).Then((entries) => ValueOrErrors.Default.return(PredicateValue.Default.record(OrderedMap(entries.map((_) => [_[0], _[1]])))));
-                }
-                return ValueOrErrors.Default.throwOne(`unsupported type ${JSON.stringify(type)}`);
-            })();
-            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When parsing expression ${JSON.stringify(json, null, 2)}`));
-        },
-        recordToTuple: (r) => {
-            const valuesSortedByName = r.fields
-                .toSeq()
-                .map((v, k) => [k, v])
-                .sortBy(([k, v]) => k)
-                .map(([k, v]) => v)
-                .valueSeq()
-                .toArray();
-            return PredicateValue.Default.tuple(List(valuesSortedByName));
-        },
-        Equals: (vars) => (v1, v2) => typeof v1 == "boolean" ||
-            typeof v1 == "number" ||
-            typeof v1 == "string" ||
-            typeof v2 == "boolean" ||
-            typeof v2 == "number" ||
-            typeof v2 == "string"
-            ? typeof v1 == typeof v2
-                ? ValueOrErrors.Default.return(v1 == v2)
-                : ValueOrErrors.Default.throwOne(`cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`)
-            : PredicateValue.Operations.IsDate(v1) &&
-                PredicateValue.Operations.IsDate(v2)
-                ? v1.getTime() == v2.getTime()
-                    ? ValueOrErrors.Default.return(true)
-                    : ValueOrErrors.Default.return(false)
-                : PredicateValue.Operations.IsUnionCase(v1) &&
-                    PredicateValue.Operations.IsUnionCase(v2)
-                    ? v1.caseName == v2.caseName
-                        ? PredicateValue.Operations.Equals(vars)(v1.fields, v2.fields)
-                        : ValueOrErrors.Default.return(false)
-                    : PredicateValue.Operations.IsTuple(v1) &&
-                        PredicateValue.Operations.IsTuple(v2)
-                        ? v1.values.size != v2.values.size
-                            ? ValueOrErrors.Default.return(false)
-                            : v1.values.size == 0
-                                ? ValueOrErrors.Default.return(true)
-                                : PredicateValue.Operations.Equals(vars)(v1.values.get(0), v2.values.get(0)).Then((firstEqual) => firstEqual
-                                    ? PredicateValue.Operations.Equals(vars)(PredicateValue.Default.tuple(v1.values.slice(1)), PredicateValue.Default.tuple(v2.values.slice(1)))
-                                    : ValueOrErrors.Default.return(false))
-                        : PredicateValue.Operations.IsRecord(v1) &&
-                            PredicateValue.Operations.IsRecord(v2)
-                            ? PredicateValue.Operations.Equals(vars)(PredicateValue.Operations.recordToTuple(v1), PredicateValue.Operations.recordToTuple(v2))
-                            : PredicateValue.Operations.IsTable(v1) &&
-                                PredicateValue.Operations.IsTable(v2)
-                                ? v1.data.size == v2.data.size
-                                    ? ValueOrErrors.Default.return(v1.data.keySeq().equals(v2.data.keySeq()))
-                                    : ValueOrErrors.Default.return(false)
-                                : PredicateValue.Operations.IsUnit(v1) &&
-                                    PredicateValue.Operations.IsUnit(v2)
-                                    ? ValueOrErrors.Default.return(true)
-                                    : PredicateValue.Operations.IsUnit(v1) !=
-                                        PredicateValue.Operations.IsUnit(v2)
-                                        ? ValueOrErrors.Default.throwOne(`cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`)
-                                        : ValueOrErrors.Default.throwOne(`structural equality is not implemented yet between ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`),
-    },
-};
-export const Expr = {
-    Default: {
-        prepend: (prependCases, e) => ({
-            kind: "prepend",
-            operands: [prependCases, e],
-        }),
-        itemLookup: (e, i) => ({
-            kind: "itemLookup",
-            operands: [e, i],
-        }),
-        fieldLookup: (e, f) => ({
-            kind: "fieldLookup",
-            operands: [e, f],
-        }),
-        isCase: (e, c) => ({
-            kind: "isCase",
-            operands: [e, c],
-        }),
-        binaryOperator: (op, e1, e2) => ({
-            kind: op,
-            operands: [e1, e2],
-        }),
-        matchCase: (operands) => ({
-            kind: "matchCase",
-            operands,
-        }),
-        lambda: (parameter, body) => ({
-            kind: "lambda",
-            parameter,
-            body,
-        }),
-        case: (caseName, handler) => ({
-            kind: "caseName",
-            caseName,
-            handler,
-        }),
-    },
-    Operations: {
-        IsPrepend: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "prepend");
-        },
-        IsItemLookup: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "itemLookup");
-        },
-        IsFieldLookup: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "fieldLookup");
-        },
-        IsIsCase: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "isCase");
-        },
-        IsBinaryOperator: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                BinaryOperatorsSet.has(e.kind));
-        },
-        IsCase: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "caseName");
-        },
-        IsCaseArray: (e) => {
-            return e.every((e) => Expr.Operations.IsCase(e));
-        },
-        AsCaseArray: (e) => {
-            return e.every((e) => Expr.Operations.IsCase(e))
-                ? ValueOrErrors.Default.return(e)
-                : ValueOrErrors.Default.throwOne(`Error: expected cases, got ${JSON.stringify(e)}`);
-        },
-        IsMatchCase: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "matchCase");
-        },
-        IsLambda: (e) => {
-            return (typeof e == "object" &&
-                !PredicateValue.Operations.IsDate(e) &&
-                e.kind == "lambda");
-        },
-        parseAsVisibilityExpression: (json) => Expr.Operations.parse(json).MapErrors((errors) => errors.map((error) => `${error}\n...When parsing visibility expression`)),
-        parseAsDisabledExpression: (json) => Expr.Operations.parse(json).MapErrors((errors) => errors.map((error) => `${error}\n...When parsing disabled expression`)),
-        parse: (json) => {
-            const asValue = PredicateValue.Operations.parse(json, { kind: "expression" }, Map());
-            if (asValue.kind == "value")
-                return asValue;
-            if (Expr.Operations.IsItemLookup(json)) {
-                const [first, second] = json["operands"];
-                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(
-                // Tuples are 1-indexed
-                Expr.Default.itemLookup(first, second - 1)));
-            }
-            if (Expr.Operations.IsFieldLookup(json)) {
-                const [first, second] = json["operands"];
-                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(Expr.Default.fieldLookup(first, second)));
-            }
-            if (Expr.Operations.IsIsCase(json)) {
-                const [first, second] = json["operands"];
-                return Expr.Operations.parse(first).Then((first) => ValueOrErrors.Default.return(Expr.Default.isCase(first, second)));
-            }
-            if (Expr.Operations.IsBinaryOperator(json)) {
-                const [first, second] = json["operands"];
-                if (BinaryOperatorsSet.contains(json["kind"])) {
-                    return Expr.Operations.parse(first).Then((first) => Expr.Operations.parse(second).Then((second) => ValueOrErrors.Default.return(Expr.Default.binaryOperator(json["kind"], first, second))));
-                }
-            }
-            if (Expr.Operations.IsMatchCase(json)) {
-                return ValueOrErrors.Operations.All(List(json["operands"].map((operand) => Expr.Operations.parse(operand)))).Then((operands) => ValueOrErrors.Default.return(Expr.Default.matchCase(operands.toArray())));
-            }
-            if (Expr.Operations.IsLambda(json)) {
-                return Expr.Operations.parse(json["body"]).Then((body) => ValueOrErrors.Default.return(Expr.Default.lambda(json["parameter"], body)));
-            }
-            if (Expr.Operations.IsCase(json)) {
-                return Expr.Operations.parse(json["handler"]).Then((handler) => Expr.Operations.IsLambda(handler)
-                    ? ValueOrErrors.Default.return(Expr.Default.case(json["caseName"], handler))
-                    : ValueOrErrors.Default.throwOne(`expected lambda expression, got ${JSON.stringify(handler)}`));
-            }
-            if (Expr.Operations.IsPrepend(json)) {
-                const [casesToPrepend, expr] = json["operands"];
-                return Expr.Operations.parse(expr).Then((expr) => ValueOrErrors.Default.return(Expr.Default.prepend(casesToPrepend, expr)));
-            }
-            return ValueOrErrors.Default.throwOne(`cannot parse ${JSON.stringify(json)} to Expr.`);
-        },
-        EvaluateAsTuple: (vars) => (e) => !PredicateValue.Operations.IsTuple(e)
-            ? ValueOrErrors.Default.throwOne(`expected tuple expression, got ${JSON.stringify(e)}`)
-            : ValueOrErrors.Default.return(e),
-        EvaluateAsRecord: (vars) => (e) => !PredicateValue.Operations.IsRecord(e)
-            ? ValueOrErrors.Default.throwOne(`expected record expression, got ${JSON.stringify(e)}`)
-            : ValueOrErrors.Default.return(e),
-        EvaluateAsUnionCase: (vars) => (e) => !PredicateValue.Operations.IsUnionCase(e)
-            ? ValueOrErrors.Default.throwOne(`expected union case expression, got ${JSON.stringify(e)}`)
-            : ValueOrErrors.Default.return(e),
-        EvaluateAsBoolean: (vars) => (e) => !PredicateValue.Operations.IsBoolean(e)
-            ? ValueOrErrors.Default.throwOne(`expected boolean expression, got ${JSON.stringify(e)}`)
-            : ValueOrErrors.Default.return(e),
-        MatchCase: (vars) => (e, cases) => Expr.Operations.Evaluate(vars)(e).Then((matchable) => PredicateValue.Operations.IsSum(matchable)
-            ? matchable.value.kind == "l"
-                ? MapRepo.Operations.tryFindWithError("Sum.Left", cases, () => `cannot find match case Sum.Left`).Then((leftCaseHandler) => Expr.Operations.Evaluate(vars.set(leftCaseHandler.parameter, matchable.value.value))(leftCaseHandler))
-                : MapRepo.Operations.tryFindWithError("Sum.Right", cases, () => `cannot find match case Sum.Right`).Then((rightCaseHandler) => Expr.Operations.Evaluate(vars.set(rightCaseHandler.parameter, matchable.value.value))(rightCaseHandler))
-            : PredicateValue.Operations.IsUnionCase(matchable)
-                ? MapRepo.Operations.tryFindWithError(matchable.caseName, cases, () => `cannot find match case ${matchable.caseName}`).Then((matchedCaseHandler) => Expr.Operations.Evaluate(vars.set(matchedCaseHandler.parameter, matchable.fields))(matchedCaseHandler))
-                : ValueOrErrors.Default.throwOne(`unsupported matchable type in MatchCase: ${JSON.stringify(matchable)}`)),
-        ComputePredicateEvaluation: (vars) => (expr) => {
-            if (typeof expr == "boolean") {
-                return ValueOrErrors.Default.return(expr);
-            }
-            return Expr.Operations.Evaluate(vars)(expr).Then((result) => {
-                if (typeof result == "boolean") {
-                    return ValueOrErrors.Default.return(result);
-                }
-                return ValueOrErrors.Default.throwOne(`Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`);
-            });
-        },
-        EvaluateAs: (as) => (vars) => (e) => {
-            return Expr.Operations.Evaluate(vars)(e).MapErrors((errors) => errors.map((error) => `${error}\n...When evaluating expression ${JSON.stringify(e)} as ${as}`));
-        },
-        Evaluate: (vars) => (e) => {
-            const result = (() => {
-                return PredicateValue.Operations.IsBoolean(e) ||
-                    PredicateValue.Operations.IsNumber(e) ||
-                    PredicateValue.Operations.IsString(e) ||
-                    PredicateValue.Operations.IsUnit(e) ||
-                    PredicateValue.Operations.IsRecord(e) ||
-                    PredicateValue.Operations.IsTuple(e) ||
-                    PredicateValue.Operations.IsUnionCase(e) ||
-                    PredicateValue.Operations.IsSum(e)
-                    ? ValueOrErrors.Default.return(e)
-                    : PredicateValue.Operations.IsVarLookup(e)
-                        ? MapRepo.Operations.tryFindWithError(e.varName, vars, () => `Error: cannot find variable ${JSON.stringify(e.varName)}`)
-                        : Expr.Operations.IsItemLookup(e)
-                            ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeTuple) => Expr.Operations.EvaluateAsTuple(vars)(maybeTuple).Then((tuple) => ListRepo.Operations.tryFindWithError(e.operands[1], tuple.values, () => `Error: cannot find element of index ${e.operands[1]} in tuple ${JSON.stringify(tuple)}`)))
-                            : Expr.Operations.IsFieldLookup(e)
-                                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeRecord) => Expr.Operations.EvaluateAsRecord(vars)(maybeRecord).Then((record) => MapRepo.Operations.tryFindWithError(e.operands[1], record.fields, () => `Error: cannot find field ${e.operands[1]}`)))
-                                : Expr.Operations.IsIsCase(e)
-                                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((maybeUnionCase) => Expr.Operations.EvaluateAsUnionCase(vars)(maybeUnionCase).Then((unionCase) => ValueOrErrors.Default.return(unionCase.caseName == e.operands[1])))
-                                    : Expr.Operations.IsMatchCase(e)
-                                        ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((matchable) => Expr.Operations.AsCaseArray(e.operands.slice(1)).Then((cases) => Expr.Operations.MatchCase(vars)(matchable, Map(cases.map((c) => [c.caseName, c.handler])))))
-                                        : Expr.Operations.IsLambda(e)
-                                            ? Expr.Operations.Evaluate(vars)(e.body)
-                                            : Expr.Operations.IsBinaryOperator(e) &&
-                                                e.kind == "equals"
-                                                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) => Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v2) => PredicateValue.Operations.Equals(vars)(v1, v2).Then((eq) => ValueOrErrors.Default.return(eq))))
-                                                : Expr.Operations.IsBinaryOperator(e) &&
-                                                    e.kind == "or"
-                                                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then((v1) => Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v2) => Expr.Operations.EvaluateAsBoolean(vars)(v1).Then((v1) => Expr.Operations.EvaluateAsBoolean(vars)(v2).Then((v2) => ValueOrErrors.Default.return(v1 || v2)))))
-                                                    : Expr.Operations.IsPrepend(e)
-                                                        ? Expr.Operations.Evaluate(vars)(e.operands[1]).Then((v) => Expr.Operations.EvaluateAsRecord(vars)(v).Then((v) => {
-                                                            const prependEntries = e.operands[0].map((c) => [
-                                                                c,
-                                                                PredicateValue.Default.record(OrderedMap([["Value", c]])),
-                                                            ]);
-                                                            const existingEntries = Array.from(v.fields.entries());
-                                                            let returnValue = PredicateValue.Default.record(OrderedMap(prependEntries.concat(existingEntries)));
-                                                            return ValueOrErrors.Default.return(returnValue);
-                                                        }))
-                                                        : ValueOrErrors.Default.throwOne(`Error: unsupported expression ${JSON.stringify(e)}`);
-            })();
-            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When evaluating expression ${JSON.stringify(e, null, 2)}`));
-        },
-    },
-};
-export const evaluatePredicates = (context, root) => {
-    const bindings = Map()
-        .set("global", context.global)
-        .set("root", root)
-        .set("local", root);
-    const traverse = (bindings, predicate, raw) => {
-        if (predicate.kind == "primitive") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                return ValueOrErrors.Default.return({
-                    kind: "primitive",
-                    value: result,
-                });
-            });
-        }
-        if (predicate.kind == "record") {
-            if (typeof raw != "object" || !("kind" in raw) || raw.kind != "record") {
-                return ValueOrErrors.Default.throwOne(`parsing expected record in raw, got ${JSON.stringify(raw)}`);
-            }
-            return calculateVisibility(predicate.value, bindings).Then((result) => ValueOrErrors.Operations.All(List(predicate.fields
-                .entrySeq()
-                .map(([fieldName, fieldPredicate]) => {
-                const fieldRaw = raw.fields.get(fieldName);
-                if (fieldRaw == undefined) {
-                    return ValueOrErrors.Default.return([
-                        fieldName,
-                        { kind: "primitive", value: false },
-                    ]);
-                }
-                if (fieldPredicate.kind == "record") {
-                    const localBindings = bindings.get("local");
-                    const fieldLocal = localBindings.fields.get(fieldName);
-                    if (fieldLocal == undefined) {
-                        return ValueOrErrors.Default.throwOne(`Error: parsing cannot find field ${fieldName} in local ${JSON.stringify(localBindings)}`);
-                    }
-                    const fieldBindings = bindings.set("local", fieldLocal);
-                    return traverse(fieldBindings, fieldPredicate, fieldRaw).Then((evaluation) => ValueOrErrors.Default.return([fieldName, evaluation]));
-                }
-                return traverse(bindings, fieldPredicate, fieldRaw).Then((evaluation) => ValueOrErrors.Default.return([fieldName, evaluation]));
-            }))).Then((evaluations) => {
-                return ValueOrErrors.Default.return({
-                    kind: "form",
-                    value: result,
-                    fields: Map(evaluations.map((_) => [_[0], _[1]])),
-                });
-            }));
-        }
-        if (predicate.kind == "list") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                if (PredicateValue.Operations.IsTuple(raw)) {
-                    return ValueOrErrors.Operations.All(List(raw.values.map((value, index) => {
-                        const elementLocal = raw.values.get(index);
-                        if (elementLocal == undefined) {
-                            return ValueOrErrors.Default.throwOne(`Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`);
-                        }
-                        const elementBindings = bindings.set("local", elementLocal);
-                        return traverse(elementBindings, predicate.elementExpression, value);
-                    }))).Then((elementResults) => {
-                        return ValueOrErrors.Default.return({
-                            kind: "list",
-                            value: result,
-                            elementValues: elementResults.toArray(),
-                        });
-                    });
-                }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple, got ${JSON.stringify(raw)}`);
-            });
-        }
-        if (predicate.kind == "map") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                if (typeof raw == "object" && "kind" in raw && raw.kind == "tuple") {
-                    return ValueOrErrors.Operations.All(List(raw.values.map((kv) => {
-                        if (PredicateValue.Operations.IsTuple(kv)) {
-                            const keyLocal = kv.values.get(0);
-                            const valueLocal = kv.values.get(1);
-                            if (keyLocal == undefined || valueLocal == undefined) {
-                                return ValueOrErrors.Default.throwOne(`Error: cannot find key or value of ${JSON.stringify(kv)} in local ${JSON.stringify(raw)}`);
-                            }
-                            const keyBindings = bindings.set("local", keyLocal);
-                            const valueBindings = bindings.set("local", valueLocal);
-                            return traverse(keyBindings, predicate.keyExpression, keyLocal).Then((keyResult) => {
-                                return traverse(valueBindings, predicate.valueExpression, valueLocal).Then((valueResult) => {
-                                    return ValueOrErrors.Default.return({
-                                        key: keyResult,
-                                        value: valueResult,
-                                    });
-                                });
-                            });
-                        }
-                        return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple of key and value, got ${JSON.stringify(kv)}`);
-                    }))).Then((keyValues) => {
-                        return ValueOrErrors.Default.return({
-                            kind: "map",
-                            value: result,
-                            elementValues: keyValues.toArray(),
-                        });
-                    });
-                }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple of key value pairs, got ${JSON.stringify(raw)}`);
-            });
-        }
-        if (predicate.kind == "tuple") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                if (PredicateValue.Operations.IsTuple(raw)) {
-                    return ValueOrErrors.Operations.All(List(raw.values.map((value, index) => {
-                        const elementLocal = raw.values.get(index);
-                        if (elementLocal == undefined) {
-                            return ValueOrErrors.Default.throwOne(`Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`);
-                        }
-                        const elementBindings = bindings.set("local", elementLocal);
-                        return traverse(elementBindings, predicate.elementExpressions[index], value);
-                    }))).Then((elementResults) => {
-                        return ValueOrErrors.Default.return({
-                            kind: "tuple",
-                            value: result,
-                            elementValues: elementResults.toArray(),
-                        });
-                    });
-                }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected tuple, got ${JSON.stringify(raw)}`);
-            });
-        }
-        if (predicate.kind == "sum") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                if (PredicateValue.Operations.IsSum(raw)) {
-                    const local = raw.value.value;
-                    const innerBindings = bindings.set("local", local);
-                    return traverse(innerBindings, raw.value.kind === "l"
-                        ? predicate.leftExpression
-                        : predicate.rightExpression, local).Then((innerRes) => {
-                        return ValueOrErrors.Default.return(FormFieldPredicateEvaluation.Default.sum(result, innerRes));
-                    });
-                }
-                return ValueOrErrors.Default.throwOne(`Error: parsing expected sum, got ${JSON.stringify(raw)}`);
-            });
-        }
-        if (predicate.kind == "unit") {
-            return calculateVisibility(predicate.value, bindings).Then((result) => {
-                return ValueOrErrors.Default.return({
-                    kind: "unit",
-                    value: result,
-                });
-            });
-        }
-        return ValueOrErrors.Default.throwOne(`Error: parsing unsupported predicate kind ${JSON.stringify(raw)}`);
-    };
-    const res = traverse(bindings, {
-        kind: "record",
-        value: true,
-        fields: context.visibilityPredicateExpressions,
-    }, root).Then((visibilities) => {
-        return traverse(bindings, {
-            kind: "record",
-            value: true,
-            fields: context.disabledPredicatedExpressions,
-        }, root).Then((disabledFields) => {
-            return ValueOrErrors.Default.return({
-                visiblityPredicateEvaluations: visibilities,
-                disabledPredicateEvaluations: disabledFields,
-            });
-        });
-    });
-    if (res.kind == "errors") {
-        console.error("error evaluating predicates", res);
-    }
-    return res;
-};
-//# sourceMappingURL=state.js.map