ballerina-core 1.0.198 → 1.0.200

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

@@ -0,0 +1,812 @@
+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 ValueTuple = {
+    Default: () => ({
+        kind: "tuple",
+        values: List(),
+    }),
+    Updaters: Object.assign({}, simpleUpdater()("values")),
+};
+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 BinaryOperators = ["or", "equals"];
+export const BinaryOperatorsSet = Set(BinaryOperators);
+export const PredicateValue = {
+    Default: {
+        string: () => "",
+        number: () => 0,
+        boolean: () => false,
+        date: () => new Date(),
+        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,
+        }),
+        table: (from, to, data, hasMoreValues) => ({
+            kind: "table",
+            from,
+            to,
+            data,
+            hasMoreValues,
+        }),
+        readonly: (value) => ({
+            kind: "readOnly",
+            ReadOnly: value,
+        }),
+    },
+    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");
+        },
+        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");
+        },
+        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: {
+        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: {
+        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)}`));
+            }
+            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.IsUnit(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)))))
+                                                    : 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