@prismatic-io/spectral 7.4.1 → 7.5.1

package/dist/conditionalLogic/index.d.ts

@@ -0,0 +1,10 @@
+import { ConditionalExpression } from "./types";
+export declare type ValidationResult = [boolean] | [boolean, string];
+export declare const validate: (expression: ConditionalExpression) => ValidationResult;
+/** Convert stringified objects/values back to their native value, all other
+ *  values just pass through unaltered. */
+export declare const parseValue: (value: unknown) => any;
+export declare const contains: (container: unknown, containee: unknown) => boolean;
+export declare const parseDate: (value: unknown) => Date;
+export declare const evaluate: (expression: ConditionalExpression) => boolean;
+export * from "./types";

package/dist/conditionalLogic/index.js

@@ -0,0 +1,252 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = exports.parseDate = exports.contains = exports.parseValue = exports.validate = void 0;
+const types_1 = require("./types");
+const date_fns_1 = require("date-fns");
+const lodash_1 = __importDefault(require("lodash"));
+const validate = (expression) => {
+    if (!(expression instanceof Array)) {
+        return [false, `Invalid expression syntax: '${expression}'`];
+    }
+    const [operator] = expression;
+    if (operator in types_1.BooleanOperator) {
+        if (operator === types_1.BooleanOperator.and || operator === types_1.BooleanOperator.or) {
+            const [, ...predicates] = expression;
+            return predicates.reduce((previous, current) => {
+                const [valid, error] = (0, exports.validate)(current);
+                if (!valid) {
+                    return [valid, [previous[1], error].filter(Boolean).join(", ")];
+                }
+                return previous;
+            }, [true]);
+        }
+        return [false, `Invalid expression syntax: '${expression}'`];
+    }
+    else if (operator in types_1.UnaryOperator || operator in types_1.BinaryOperator) {
+        return [true];
+    }
+    return [false, `Invalid expression syntax: '${expression}'`];
+};
+exports.validate = validate;
+/** Convert stringified objects/values back to their native value, all other
+ *  values just pass through unaltered. */
+const parseValue = (value) => {
+    try {
+        return typeof value === "string" ? JSON.parse(value) : value;
+    }
+    catch (_a) {
+        return value;
+    }
+};
+exports.parseValue = parseValue;
+const contains = (container, containee) => {
+    if (typeof container === "string") {
+        // Substring check.
+        // NOTE: JS is real fast and loose with types here, happily returning true
+        // for things like "123".includes(1), but we have to lie to TS.
+        return container.includes(`${containee}`);
+    }
+    if (typeof container === "object" && container !== null) {
+        if (Array.isArray(container)) {
+            // Array member check.
+            return container.includes(containee);
+        }
+        // Object attribute check (set membership).
+        return Object.prototype.hasOwnProperty.call(container, `${containee}`);
+    }
+    throw new Error("Invalid arguments set to 'contains'.");
+};
+exports.contains = contains;
+const parseDate = (value) => {
+    if (value instanceof Date && (0, date_fns_1.isValid)(value)) {
+        return value;
+    }
+    if (typeof value === "number") {
+        return new Date(value);
+    }
+    if (typeof value === "string") {
+        const dateFormats = ["yyyy", "yyyy-MM-dd"];
+        for (const format of dateFormats) {
+            const parsed = (0, date_fns_1.parse)(value, format, 0);
+            if ((0, date_fns_1.isValid)(parsed)) {
+                return parsed;
+            }
+        }
+        const isoParsed = (0, date_fns_1.parseISO)(value);
+        if ((0, date_fns_1.isValid)(isoParsed)) {
+            return isoParsed;
+        }
+    }
+    throw new Error("Invalid argument type");
+};
+exports.parseDate = parseDate;
+const isEqual = (left, right) => left == right ||
+    lodash_1.default.isEqualWith(left, right, (objectA, objectB) => {
+        if (typeof objectA === "object" || typeof objectB === "object") {
+            /**
+             * `undefined` will fall back to the default isEqual behavior.
+             * @see -> (https://lodash.com/docs/4.17.15#isEqualWith)
+             */
+            return undefined;
+        }
+        return objectA == objectB;
+    });
+const evaluate = (expression) => {
+    const [valid, message] = (0, exports.validate)(expression);
+    if (!valid) {
+        throw new Error(message);
+    }
+    const [operator] = expression;
+    if (operator in types_1.BooleanOperator) {
+        const predicates = expression.slice(1);
+        const results = predicates.map(exports.evaluate);
+        switch (operator) {
+            case types_1.BooleanOperator.and:
+                return results.reduce((previous, current) => previous && current, true);
+            case types_1.BooleanOperator.or:
+                return results.reduce((previous, current) => previous || current, false);
+            default:
+                throw new Error(`Invalid operator: '${operator}'`);
+        }
+    }
+    else if (operator in types_1.UnaryOperator) {
+        const [, leftTerm] = expression;
+        const left = (0, exports.parseValue)(leftTerm);
+        // attempt to compare
+        try {
+            switch (operator) {
+                case types_1.UnaryOperator.isTrue:
+                    if (typeof left === "string") {
+                        const lowerValue = left.toLowerCase();
+                        if (["t", "true", "y", "yes"].includes(lowerValue)) {
+                            return true;
+                        }
+                        else if (["f", "false", "n", "no"].includes(lowerValue)) {
+                            return false;
+                        }
+                    }
+                    return !!left;
+                case types_1.UnaryOperator.isFalse:
+                    if (typeof left === "string") {
+                        const lowerValue = left.toLowerCase();
+                        if (["t", "true", "y", "yes"].includes(lowerValue)) {
+                            return false;
+                        }
+                        else if (["f", "false", "n", "no"].includes(lowerValue)) {
+                            return true;
+                        }
+                    }
+                    return !left;
+                case types_1.UnaryOperator.doesNotExist:
+                    return [undefined, null, 0, NaN, false, ""].includes(left);
+                case types_1.UnaryOperator.exists:
+                    return ![undefined, null, 0, NaN, false, ""].includes(left);
+                case types_1.UnaryOperator.isEmpty:
+                    if (Array.isArray(left)) {
+                        return left.length === 0;
+                    }
+                    // leftTerm is used here, since "123" would be cast to 123 and would not be a string
+                    if (typeof leftTerm === "string") {
+                        return leftTerm.length === 0;
+                    }
+                    throw new Error("Please provide an array or string");
+                case types_1.UnaryOperator.isNotEmpty:
+                    if (Array.isArray(left)) {
+                        return left.length > 0;
+                    }
+                    if (typeof leftTerm === "string") {
+                        return leftTerm.length > 0;
+                    }
+                    throw new Error("Please provide an array or string");
+                default:
+                    throw new Error(`Invalid operator: '${operator}'`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Incompatible comparison arguments, ${error}`);
+        }
+    }
+    else {
+        const [, leftTerm, rightTerm] = expression;
+        let left = null;
+        let right = null;
+        // attempt to convert numeric, array, or object strings as json to native objects,
+        // otherwise fall back to original value
+        if (operator in
+            [
+                types_1.BinaryOperator.dateTimeAfter,
+                types_1.BinaryOperator.dateTimeBefore,
+                types_1.BinaryOperator.dateTimeSame,
+            ]) {
+            left = (0, exports.parseDate)(leftTerm);
+            right = (0, exports.parseDate)(rightTerm);
+        }
+        else {
+            left = (0, exports.parseValue)(leftTerm);
+            right = (0, exports.parseValue)(rightTerm);
+        }
+        // attempt to compare
+        try {
+            switch (operator) {
+                case types_1.BinaryOperator.equal:
+                    return isEqual(left, right);
+                case types_1.BinaryOperator.notEqual:
+                    return !isEqual(left, right);
+                case types_1.BinaryOperator.greaterThan:
+                    return left > right;
+                case types_1.BinaryOperator.greaterThanOrEqual:
+                    return left >= right;
+                case types_1.BinaryOperator.lessThan:
+                    return left < right;
+                case types_1.BinaryOperator.lessThanOrEqual:
+                    return left <= right;
+                case types_1.BinaryOperator.in:
+                    return (0, exports.contains)(right, left);
+                case types_1.BinaryOperator.notIn:
+                    return !(0, exports.contains)(right, left);
+                case types_1.BinaryOperator.exactlyMatches:
+                    return left === right || lodash_1.default.isEqual(left, right);
+                case types_1.BinaryOperator.doesNotExactlyMatch:
+                    return !(left === right || lodash_1.default.isEqual(left, right));
+                case types_1.BinaryOperator.startsWith:
+                    return `${right}`.startsWith(`${left}`);
+                case types_1.BinaryOperator.doesNotStartWith:
+                    return !`${right}`.startsWith(`${left}`);
+                case types_1.BinaryOperator.endsWith:
+                    return `${right}`.endsWith(`${left}`);
+                case types_1.BinaryOperator.doesNotEndWith:
+                    return !`${right}`.endsWith(`${left}`);
+                case types_1.BinaryOperator.dateTimeAfter:
+                    return (0, date_fns_1.isAfter)(left, right);
+                case types_1.BinaryOperator.dateTimeBefore:
+                    return (0, date_fns_1.isBefore)(left, right);
+                case types_1.BinaryOperator.dateTimeSame:
+                    return left == right;
+                default:
+                    throw new Error(`Invalid operator: '${operator}'`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Incompatible comparison arguments, ${error}`);
+        }
+    }
+};
+exports.evaluate = evaluate;
+__exportStar(require("./types"), exports);

package/dist/conditionalLogic/types.d.ts

@@ -0,0 +1,92 @@
+export declare enum BooleanOperator {
+    and = "and",
+    or = "or"
+}
+export declare const BooleanOperatorPhrase: string[];
+export declare enum UnaryOperator {
+    isTrue = "isTrue",
+    isFalse = "isFalse",
+    doesNotExist = "doesNotExist",
+    exists = "exists",
+    isEmpty = "isEmpty",
+    isNotEmpty = "isNotEmpty"
+}
+export declare const UnaryOperatorPhrase: {
+    isTrue: string;
+    isFalse: string;
+    doesNotExist: string;
+    exists: string;
+    isEmpty: string;
+    isNotEmpty: string;
+};
+export declare enum BinaryOperator {
+    equal = "equal",
+    notEqual = "notEqual",
+    greaterThan = "greaterThan",
+    greaterThanOrEqual = "greaterThanOrEqual",
+    lessThan = "lessThan",
+    lessThanOrEqual = "lessThanOrEqual",
+    in = "in",
+    notIn = "notIn",
+    exactlyMatches = "exactlyMatches",
+    doesNotExactlyMatch = "doesNotExactlyMatch",
+    startsWith = "startsWith",
+    doesNotStartWith = "doesNotStartWith",
+    endsWith = "endsWith",
+    doesNotEndWith = "doesNotEndWith",
+    dateTimeAfter = "dateTimeAfter",
+    dateTimeBefore = "dateTimeBefore",
+    dateTimeSame = "dateTimeSame"
+}
+export declare const BinaryOperatorPhrase: {
+    equal: string;
+    notEqual: string;
+    greaterThan: string;
+    greaterThanOrEqual: string;
+    lessThan: string;
+    lessThanOrEqual: string;
+    in: string;
+    notIn: string;
+    exactlyMatches: string;
+    doesNotExactlyMatch: string;
+    startsWith: string;
+    doesNotStartWith: string;
+    endsWith: string;
+    doesNotEndWith: string;
+    dateTimeAfter: string;
+    dateTimeBefore: string;
+    dateTimeSame: string;
+};
+export declare type TermOperator = UnaryOperator | BinaryOperator;
+export declare const TermOperatorPhrase: {
+    equal: string;
+    notEqual: string;
+    greaterThan: string;
+    greaterThanOrEqual: string;
+    lessThan: string;
+    lessThanOrEqual: string;
+    in: string;
+    notIn: string;
+    exactlyMatches: string;
+    doesNotExactlyMatch: string;
+    startsWith: string;
+    doesNotStartWith: string;
+    endsWith: string;
+    doesNotEndWith: string;
+    dateTimeAfter: string;
+    dateTimeBefore: string;
+    dateTimeSame: string;
+    isTrue: string;
+    isFalse: string;
+    doesNotExist: string;
+    exists: string;
+    isEmpty: string;
+    isNotEmpty: string;
+};
+export declare type Term = unknown;
+export declare type TermExpression = [TermOperator, Term, Term?];
+export declare type BooleanExpression = [
+    BooleanOperator.and | BooleanOperator.or,
+    ...ConditionalExpression[]
+];
+export declare type ConditionalExpression = TermExpression | BooleanExpression;

package/dist/conditionalLogic/types.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TermOperatorPhrase = exports.BinaryOperatorPhrase = exports.BinaryOperator = exports.UnaryOperatorPhrase = exports.UnaryOperator = exports.BooleanOperatorPhrase = exports.BooleanOperator = void 0;
+// GraphQL-derived enums use the same name as the constant for the value,
+// but depending on how things shake out, we may be able to combine with the phrases below.
+var BooleanOperator;
+(function (BooleanOperator) {
+    BooleanOperator["and"] = "and";
+    BooleanOperator["or"] = "or";
+})(BooleanOperator = exports.BooleanOperator || (exports.BooleanOperator = {}));
+exports.BooleanOperatorPhrase = Object.keys(BooleanOperator);
+var UnaryOperator;
+(function (UnaryOperator) {
+    UnaryOperator["isTrue"] = "isTrue";
+    UnaryOperator["isFalse"] = "isFalse";
+    UnaryOperator["doesNotExist"] = "doesNotExist";
+    UnaryOperator["exists"] = "exists";
+    UnaryOperator["isEmpty"] = "isEmpty";
+    UnaryOperator["isNotEmpty"] = "isNotEmpty";
+})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
+exports.UnaryOperatorPhrase = {
+    [UnaryOperator.isTrue]: "is true",
+    [UnaryOperator.isFalse]: "is false",
+    [UnaryOperator.doesNotExist]: "does not exist",
+    [UnaryOperator.exists]: "exists",
+    [UnaryOperator.isEmpty]: "is empty",
+    [UnaryOperator.isNotEmpty]: "is not empty",
+};
+var BinaryOperator;
+(function (BinaryOperator) {
+    BinaryOperator["equal"] = "equal";
+    BinaryOperator["notEqual"] = "notEqual";
+    BinaryOperator["greaterThan"] = "greaterThan";
+    BinaryOperator["greaterThanOrEqual"] = "greaterThanOrEqual";
+    BinaryOperator["lessThan"] = "lessThan";
+    BinaryOperator["lessThanOrEqual"] = "lessThanOrEqual";
+    BinaryOperator["in"] = "in";
+    BinaryOperator["notIn"] = "notIn";
+    BinaryOperator["exactlyMatches"] = "exactlyMatches";
+    BinaryOperator["doesNotExactlyMatch"] = "doesNotExactlyMatch";
+    BinaryOperator["startsWith"] = "startsWith";
+    BinaryOperator["doesNotStartWith"] = "doesNotStartWith";
+    BinaryOperator["endsWith"] = "endsWith";
+    BinaryOperator["doesNotEndWith"] = "doesNotEndWith";
+    BinaryOperator["dateTimeAfter"] = "dateTimeAfter";
+    BinaryOperator["dateTimeBefore"] = "dateTimeBefore";
+    BinaryOperator["dateTimeSame"] = "dateTimeSame";
+})(BinaryOperator = exports.BinaryOperator || (exports.BinaryOperator = {}));
+exports.BinaryOperatorPhrase = {
+    [BinaryOperator.equal]: "equal",
+    [BinaryOperator.notEqual]: "does not equal",
+    [BinaryOperator.greaterThan]: "is greater than",
+    [BinaryOperator.greaterThanOrEqual]: "is greater than or equal to",
+    [BinaryOperator.lessThan]: "is less than",
+    [BinaryOperator.lessThanOrEqual]: "is less than or equal to",
+    [BinaryOperator.in]: "contained in",
+    [BinaryOperator.notIn]: "not contained in",
+    [BinaryOperator.exactlyMatches]: "exactly matches",
+    [BinaryOperator.doesNotExactlyMatch]: "does not exactly match",
+    [BinaryOperator.startsWith]: "starts with",
+    [BinaryOperator.doesNotStartWith]: "does not start with",
+    [BinaryOperator.endsWith]: "ends with",
+    [BinaryOperator.doesNotEndWith]: "does not end with",
+    [BinaryOperator.dateTimeAfter]: "is after (date/time)",
+    [BinaryOperator.dateTimeBefore]: "is before (date/time)",
+    [BinaryOperator.dateTimeSame]: "is the same (date/time)",
+};
+exports.TermOperatorPhrase = Object.assign(Object.assign({}, exports.UnaryOperatorPhrase), exports.BinaryOperatorPhrase);

package/dist/types/Inputs.d.ts

@@ -146,7 +146,7 @@ export interface ConditionalInputField extends BaseInputField {
     /** Data type the InputField will collect. */
     type: "conditional";
     /** Collection type of the InputField */
-    collection: Extract<InputFieldCollection, "valuelist">;
+    collection: InputFieldCollection;
     /** Default value for this field. */
     default?: ConditionalExpression;
     /** Clean function */

package/dist/types/conditional-logic.d.ts

@@ -1,91 +1 @@
-/**
- * This file contains types to help define conditional logic for the Prismatic
- * branch component, https://prismatic.io/docs/components/branch/
- */
-/** @ignore */
-export declare enum BooleanOperator {
-    and = "and",
-    or = "or"
-}
-export declare const BooleanOperatorPhrase: string[];
-export declare enum UnaryOperator {
-    isTrue = "isTrue",
-    isFalse = "isFalse",
-    doesNotExist = "doesNotExist",
-    exists = "exists"
-}
-export declare const UnaryOperatorPhrase: {
-    isTrue: string;
-    isFalse: string;
-    doesNotExist: string;
-    exists: string;
-};
-export declare enum BinaryOperator {
-    equal = "equal",
-    notEqual = "notEqual",
-    greaterThan = "greaterThan",
-    greaterThanOrEqual = "greaterThanOrEqual",
-    lessThan = "lessThan",
-    lessThanOrEqual = "lessThanOrEqual",
-    in = "in",
-    notIn = "notIn",
-    exactlyMatches = "exactlyMatches",
-    doesNotExactlyMatch = "doesNotExactlyMatch",
-    startsWith = "startsWith",
-    doesNotStartWith = "doesNotStartWith",
-    endsWith = "endsWith",
-    doesNotEndWith = "doesNotEndWith",
-    dateTimeAfter = "dateTimeAfter",
-    dateTimeBefore = "dateTimeBefore",
-    dateTimeSame = "dateTimeSame"
-}
-export declare const BinaryOperatorPhrase: {
-    equal: string;
-    notEqual: string;
-    greaterThan: string;
-    greaterThanOrEqual: string;
-    lessThan: string;
-    lessThanOrEqual: string;
-    in: string;
-    notIn: string;
-    exactlyMatches: string;
-    doesNotExactlyMatch: string;
-    startsWith: string;
-    doesNotStartWith: string;
-    endsWith: string;
-    doesNotEndWith: string;
-    dateTimeAfter: string;
-    dateTimeBefore: string;
-    dateTimeSame: string;
-};
-export declare type TermOperator = UnaryOperator | BinaryOperator;
-export declare const TermOperatorPhrase: {
-    equal: string;
-    notEqual: string;
-    greaterThan: string;
-    greaterThanOrEqual: string;
-    lessThan: string;
-    lessThanOrEqual: string;
-    in: string;
-    notIn: string;
-    exactlyMatches: string;
-    doesNotExactlyMatch: string;
-    startsWith: string;
-    doesNotStartWith: string;
-    endsWith: string;
-    doesNotEndWith: string;
-    dateTimeAfter: string;
-    dateTimeBefore: string;
-    dateTimeSame: string;
-    isTrue: string;
-    isFalse: string;
-    doesNotExist: string;
-    exists: string;
-};
-export declare type Term = unknown;
-export declare type TermExpression = [TermOperator, Term, Term?];
-export declare type BooleanExpression = [
-    BooleanOperator.and | BooleanOperator.or,
-    ...ConditionalExpression[]
-];
-export declare type ConditionalExpression = TermExpression | BooleanExpression;
+export * from "../conditionalLogic/types";

package/dist/types/conditional-logic.js

@@ -1,67 +1,17 @@
 "use strict";
-/**
- * This file contains types to help define conditional logic for the Prismatic
- * branch component, https://prismatic.io/docs/components/branch/
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TermOperatorPhrase = exports.BinaryOperatorPhrase = exports.BinaryOperator = exports.UnaryOperatorPhrase = exports.UnaryOperator = exports.BooleanOperatorPhrase = exports.BooleanOperator = void 0;
-/** @ignore */
-var BooleanOperator;
-(function (BooleanOperator) {
-    BooleanOperator["and"] = "and";
-    BooleanOperator["or"] = "or";
-})(BooleanOperator = exports.BooleanOperator || (exports.BooleanOperator = {}));
-exports.BooleanOperatorPhrase = Object.keys(BooleanOperator);
-var UnaryOperator;
-(function (UnaryOperator) {
-    UnaryOperator["isTrue"] = "isTrue";
-    UnaryOperator["isFalse"] = "isFalse";
-    UnaryOperator["doesNotExist"] = "doesNotExist";
-    UnaryOperator["exists"] = "exists";
-})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
-exports.UnaryOperatorPhrase = {
-    [UnaryOperator.isTrue]: "is true",
-    [UnaryOperator.isFalse]: "is false",
-    [UnaryOperator.doesNotExist]: "does not exist",
-    [UnaryOperator.exists]: "exists",
-};
-var BinaryOperator;
-(function (BinaryOperator) {
-    BinaryOperator["equal"] = "equal";
-    BinaryOperator["notEqual"] = "notEqual";
-    BinaryOperator["greaterThan"] = "greaterThan";
-    BinaryOperator["greaterThanOrEqual"] = "greaterThanOrEqual";
-    BinaryOperator["lessThan"] = "lessThan";
-    BinaryOperator["lessThanOrEqual"] = "lessThanOrEqual";
-    BinaryOperator["in"] = "in";
-    BinaryOperator["notIn"] = "notIn";
-    BinaryOperator["exactlyMatches"] = "exactlyMatches";
-    BinaryOperator["doesNotExactlyMatch"] = "doesNotExactlyMatch";
-    BinaryOperator["startsWith"] = "startsWith";
-    BinaryOperator["doesNotStartWith"] = "doesNotStartWith";
-    BinaryOperator["endsWith"] = "endsWith";
-    BinaryOperator["doesNotEndWith"] = "doesNotEndWith";
-    BinaryOperator["dateTimeAfter"] = "dateTimeAfter";
-    BinaryOperator["dateTimeBefore"] = "dateTimeBefore";
-    BinaryOperator["dateTimeSame"] = "dateTimeSame";
-})(BinaryOperator = exports.BinaryOperator || (exports.BinaryOperator = {}));
-exports.BinaryOperatorPhrase = {
-    [BinaryOperator.equal]: "equal",
-    [BinaryOperator.notEqual]: "does not equal",
-    [BinaryOperator.greaterThan]: "is greater than",
-    [BinaryOperator.greaterThanOrEqual]: "is greater than or equal to",
-    [BinaryOperator.lessThan]: "is less than",
-    [BinaryOperator.lessThanOrEqual]: "is less than or equal to",
-    [BinaryOperator.in]: "contained in",
-    [BinaryOperator.notIn]: "not contained in",
-    [BinaryOperator.exactlyMatches]: "exactly matches",
-    [BinaryOperator.doesNotExactlyMatch]: "does not exactly match",
-    [BinaryOperator.startsWith]: "starts with",
-    [BinaryOperator.doesNotStartWith]: "does not start with",
-    [BinaryOperator.endsWith]: "ends with",
-    [BinaryOperator.doesNotEndWith]: "does not end with",
-    [BinaryOperator.dateTimeAfter]: "is after (date/time)",
-    [BinaryOperator.dateTimeBefore]: "is before (date/time)",
-    [BinaryOperator.dateTimeSame]: "is the same (date/time)",
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.TermOperatorPhrase = Object.assign(Object.assign({}, exports.UnaryOperatorPhrase), exports.BinaryOperatorPhrase);
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../conditionalLogic/types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "7.4.1",
+  "version": "7.5.1",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"
@@ -40,7 +40,7 @@
     "@jsonforms/core": "3.0.0",
     "axios": "0.27.2",
     "axios-retry": "3.2.5",
-    "date-fns": "2.28.0",
+    "date-fns": "2.29.3",
     "form-data": "4.0.0",
     "jest-mock": "27.0.3",
     "soap": "1.0.0",