@bessemer/cornerstone 0.5.1 → 0.5.4

package/dist/equalitor.js

@@ -0,0 +1,10 @@
+// src/equalitor.ts
+var fromComparator = (comparator) => {
+  return (first, second) => comparator(first, second) === 0;
+};
+var reference = () => (first, second) => first === second;
+export {
+  fromComparator,
+  reference
+};
+//# sourceMappingURL=equalitor.js.map

package/dist/equalitor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/equalitor.ts"],"sourcesContent":["import { Comparator } from '@bessemer/cornerstone/comparator'\n\nexport type Equalitor<T> = (first: T, second: T) => boolean\n\nexport const fromComparator = <T>(comparator: Comparator<T>): Equalitor<T> => {\n  return (first, second) => comparator(first, second) === 0\n}\n\nexport const reference =\n  <T>(): Equalitor<T> =>\n  (first, second) =>\n    first === second\n"],"mappings":";AAIO,IAAM,iBAAiB,CAAI,eAA4C;AAC5E,SAAO,CAAC,OAAO,WAAW,WAAW,OAAO,MAAM,MAAM;AAC1D;AAEO,IAAM,YACX,MACA,CAAC,OAAO,WACN,UAAU;","names":[]}

package/dist/error-event.d.ts

@@ -0,0 +1,34 @@
+import { NominalType, Throwable } from '@bessemer/cornerstone/types';
+import { RecordAttribute } from '@bessemer/cornerstone/object';
+export type ErrorCode = NominalType<string, 'ErrorCode'>;
+export type ErrorAttribute<Type = unknown> = RecordAttribute<Type, 'ErrorAttribute'>;
+export type ErrorEvent = {
+    code: ErrorCode;
+    message: string;
+    attributes: Record<ErrorAttribute, unknown>;
+    causes: Array<ErrorEvent>;
+};
+export type ErrorEventBuilder = {
+    code: ErrorCode;
+    message?: string | null;
+    attributes?: Record<ErrorAttribute, unknown>;
+    causes?: Array<ErrorEvent>;
+};
+export declare class ErrorEventException extends Error {
+    readonly errorEvent: ErrorEvent;
+    constructor(errorEvent: ErrorEvent, cause?: unknown);
+}
+export declare const isErrorEvent: (throwable: Throwable) => throwable is ErrorEvent;
+export declare const isErrorEventException: (throwable: Throwable) => throwable is ErrorEventException;
+export declare const of: (builder: ErrorEventBuilder) => ErrorEvent;
+export declare const from: (throwable: Throwable) => ErrorEvent;
+export declare const findByCodeInCausalChain: (error: ErrorEvent, code: string) => ErrorEvent | undefined;
+export declare const findInCausalChain: (error: ErrorEvent, predicate: (error: ErrorEvent) => boolean) => ErrorEvent | undefined;
+export declare const aggregate: (builder: ErrorEventBuilder, causes: Array<ErrorEvent>) => ErrorEvent | undefined;
+export declare const UnhandledErrorCode: ErrorCode;
+export declare const NotFoundErrorCode: ErrorCode;
+export declare const RequestCorrelationIdAttribute: ErrorAttribute<string>;
+export declare const HttpStatusCodeAttribute: ErrorAttribute<number>;
+export declare const unhandled: (builder?: ErrorEventBuilder) => ErrorEvent;
+export declare const notFound: (builder?: ErrorEventBuilder) => ErrorEvent;
+//# sourceMappingURL=error-event.d.ts.map

package/dist/error-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-event.d.ts","sourceRoot":"","sources":["../src/error-event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAO9D,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AACxD,MAAM,MAAM,cAAc,CAAC,IAAI,GAAG,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;AAEpF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAA;IAC3C,MAAM,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;CAC1B,CAAA;AAGD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAA;IAC5C,MAAM,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;CAC3B,CAAA;AAGD,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;gBAEnB,UAAU,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,OAAO;CAKpD;AAED,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,KAAG,SAAS,IAAI,UAMhE,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,WAAW,SAAS,KAAG,SAAS,IAAI,mBAEzE,CAAA;AAED,eAAO,MAAM,EAAE,GAAI,SAAS,iBAAiB,KAAG,UAS/C,CAAA;AAED,eAAO,MAAM,IAAI,GAAI,WAAW,SAAS,KAAG,UAe3C,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,OAAO,UAAU,EAAE,MAAM,MAAM,KAAG,UAAU,GAAG,SAEtF,CAAA;AAOD,eAAO,MAAM,iBAAiB,GAAI,OAAO,UAAU,EAAE,WAAW,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,KAAG,UAAU,GAAG,SAM7G,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,SAAS,iBAAiB,EAAE,QAAQ,KAAK,CAAC,UAAU,CAAC,KAAG,UAAU,GAAG,SAM9F,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAmC,CAAA;AACpE,eAAO,MAAM,iBAAiB,EAAE,SAAmC,CAAA;AAEnE,eAAO,MAAM,6BAA6B,EAAE,cAAc,CAAC,MAAM,CAA0B,CAAA;AAC3F,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,MAAM,CAAoB,CAAA;AAE/E,eAAO,MAAM,SAAS,GAAI,UAAU,iBAAiB,eAOlD,CAAA;AAEH,eAAO,MAAM,QAAQ,GAAI,UAAU,iBAAiB,eAOjD,CAAA"}

package/dist/error-event.js

@@ -0,0 +1,91 @@
+// src/error-event.ts
+import { Arrays, Errors, Objects } from "@bessemer/cornerstone";
+var ErrorEventException = class extends Error {
+  errorEvent;
+  constructor(errorEvent, cause) {
+    super(errorEvent.message ?? "", { cause });
+    this.name = this.constructor.name;
+    this.errorEvent = errorEvent;
+  }
+};
+var isErrorEvent = (throwable) => {
+  if (!Objects.isObject(throwable)) {
+    return false;
+  }
+  return "code" in throwable && "message" in throwable && "attributes" in throwable && "causes" in throwable;
+};
+var isErrorEventException = (throwable) => {
+  return throwable instanceof ErrorEventException;
+};
+var of = (builder) => {
+  const code = builder.code;
+  return {
+    code,
+    message: builder.message ?? code,
+    attributes: builder.attributes ?? {},
+    causes: builder.causes ?? []
+  };
+};
+var from = (throwable) => {
+  if (isErrorEvent(throwable)) {
+    return throwable;
+  }
+  if (!Errors.isError(throwable)) {
+    return unhandled();
+  }
+  const errorEventException = Errors.findInCausalChain(throwable, isErrorEventException);
+  if (Objects.isNil(errorEventException)) {
+    return unhandled();
+  }
+  return errorEventException.errorEvent;
+};
+var findByCodeInCausalChain = (error, code) => {
+  return findInCausalChain(error, (it) => it.code === code);
+};
+var findInCausalChain = (error, predicate) => {
+  if (predicate(error)) {
+    return error;
+  }
+  return Arrays.first(error.causes.map((it) => findInCausalChain(it, predicate)).filter(Objects.isPresent));
+};
+var aggregate = (builder, causes) => {
+  if (causes.length === 0) {
+    return void 0;
+  }
+  return of({ ...builder, causes });
+};
+var UnhandledErrorCode = "error-event.unhandled";
+var NotFoundErrorCode = "error-event.not-found";
+var RequestCorrelationIdAttribute = "requestCorrelationId";
+var HttpStatusCodeAttribute = "httpStatusCode";
+var unhandled = (builder) => of(
+  Objects.merge(builder, {
+    code: UnhandledErrorCode,
+    message: "An Unhandled Error has occurred.",
+    attributes: { [HttpStatusCodeAttribute]: 500 }
+  })
+);
+var notFound = (builder) => of(
+  Objects.merge(builder, {
+    code: NotFoundErrorCode,
+    message: "The requested Resource could not be found.",
+    attributes: { [HttpStatusCodeAttribute]: 404 }
+  })
+);
+export {
+  ErrorEventException,
+  HttpStatusCodeAttribute,
+  NotFoundErrorCode,
+  RequestCorrelationIdAttribute,
+  UnhandledErrorCode,
+  aggregate,
+  findByCodeInCausalChain,
+  findInCausalChain,
+  from,
+  isErrorEvent,
+  isErrorEventException,
+  notFound,
+  of,
+  unhandled
+};
+//# sourceMappingURL=error-event.js.map

package/dist/error-event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/error-event.ts"],"sourcesContent":["import { Arrays, Errors, Objects } from '@bessemer/cornerstone'\nimport { NominalType, Throwable } from '@bessemer/cornerstone/types'\nimport { RecordAttribute } from '@bessemer/cornerstone/object'\n\n/*\n  Represents a structured error event. The code can be mapped to a unique type of error while the\n  message and attributes can provide contextual information about the error. Finally,\n  an ErrorEvent could have multiple causes which get aggregated into a single parent error.\n */\nexport type ErrorCode = NominalType<string, 'ErrorCode'>\nexport type ErrorAttribute<Type = unknown> = RecordAttribute<Type, 'ErrorAttribute'>\n\nexport type ErrorEvent = {\n  code: ErrorCode\n  message: string\n  attributes: Record<ErrorAttribute, unknown>\n  causes: Array<ErrorEvent>\n}\n\n// Builder object that allows for 'partial' representation of ErrorEvents\nexport type ErrorEventBuilder = {\n  code: ErrorCode\n  message?: string | null\n  attributes?: Record<ErrorAttribute, unknown>\n  causes?: Array<ErrorEvent>\n}\n\n// An exception type that contains an ErrorEvent\nexport class ErrorEventException extends Error {\n  readonly errorEvent: ErrorEvent\n\n  constructor(errorEvent: ErrorEvent, cause?: unknown) {\n    super(errorEvent.message ?? '', { cause })\n    this.name = this.constructor.name\n    this.errorEvent = errorEvent\n  }\n}\n\nexport const isErrorEvent = (throwable: Throwable): throwable is ErrorEvent => {\n  if (!Objects.isObject(throwable)) {\n    return false\n  }\n\n  return 'code' in throwable && 'message' in throwable && 'attributes' in throwable && 'causes' in throwable\n}\n\nexport const isErrorEventException = (throwable: Throwable): throwable is ErrorEventException => {\n  return throwable instanceof ErrorEventException\n}\n\nexport const of = (builder: ErrorEventBuilder): ErrorEvent => {\n  const code = builder.code\n\n  return {\n    code,\n    message: builder.message ?? code,\n    attributes: builder.attributes ?? {},\n    causes: builder.causes ?? [],\n  }\n}\n\nexport const from = (throwable: Throwable): ErrorEvent => {\n  if (isErrorEvent(throwable)) {\n    return throwable\n  }\n\n  if (!Errors.isError(throwable)) {\n    return unhandled()\n  }\n\n  const errorEventException = Errors.findInCausalChain(throwable, isErrorEventException) as ErrorEventException | undefined\n  if (Objects.isNil(errorEventException)) {\n    return unhandled()\n  }\n\n  return errorEventException.errorEvent\n}\n\nexport const findByCodeInCausalChain = (error: ErrorEvent, code: string): ErrorEvent | undefined => {\n  return findInCausalChain(error, (it) => it.code === code)\n}\n\n/*\n   Traverses the causal chain of the ErrorEvent, searching for a predicate that matches (including matching on the parent error event)\n   This is useful if you want to find whether or not a given error was caused by a specific failure. The search executes depth-first and\n   will return te first matching instance that satisfies the predicate, or undefined otherwise\n */\nexport const findInCausalChain = (error: ErrorEvent, predicate: (error: ErrorEvent) => boolean): ErrorEvent | undefined => {\n  if (predicate(error)) {\n    return error\n  }\n\n  return Arrays.first(error.causes.map((it) => findInCausalChain(it, predicate)).filter(Objects.isPresent))\n}\n\nexport const aggregate = (builder: ErrorEventBuilder, causes: Array<ErrorEvent>): ErrorEvent | undefined => {\n  if (causes.length === 0) {\n    return undefined\n  }\n\n  return of({ ...builder, causes })\n}\n\nexport const UnhandledErrorCode: ErrorCode = 'error-event.unhandled'\nexport const NotFoundErrorCode: ErrorCode = 'error-event.not-found'\n\nexport const RequestCorrelationIdAttribute: ErrorAttribute<string> = 'requestCorrelationId'\nexport const HttpStatusCodeAttribute: ErrorAttribute<number> = 'httpStatusCode'\n\nexport const unhandled = (builder?: ErrorEventBuilder) =>\n  of(\n    Objects.merge(builder, {\n      code: UnhandledErrorCode,\n      message: 'An Unhandled Error has occurred.',\n      attributes: { [HttpStatusCodeAttribute]: 500 },\n    })\n  )\n\nexport const notFound = (builder?: ErrorEventBuilder) =>\n  of(\n    Objects.merge(builder, {\n      code: NotFoundErrorCode,\n      message: 'The requested Resource could not be found.',\n      attributes: { [HttpStatusCodeAttribute]: 404 },\n    })\n  )\n"],"mappings":";AAAA,SAAS,QAAQ,QAAQ,eAAe;AA4BjC,IAAM,sBAAN,cAAkC,MAAM;AAAA,EACpC;AAAA,EAET,YAAY,YAAwB,OAAiB;AACnD,UAAM,WAAW,WAAW,IAAI,EAAE,MAAM,CAAC;AACzC,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,aAAa;AAAA,EACpB;AACF;AAEO,IAAM,eAAe,CAAC,cAAkD;AAC7E,MAAI,CAAC,QAAQ,SAAS,SAAS,GAAG;AAChC,WAAO;AAAA,EACT;AAEA,SAAO,UAAU,aAAa,aAAa,aAAa,gBAAgB,aAAa,YAAY;AACnG;AAEO,IAAM,wBAAwB,CAAC,cAA2D;AAC/F,SAAO,qBAAqB;AAC9B;AAEO,IAAM,KAAK,CAAC,YAA2C;AAC5D,QAAM,OAAO,QAAQ;AAErB,SAAO;AAAA,IACL;AAAA,IACA,SAAS,QAAQ,WAAW;AAAA,IAC5B,YAAY,QAAQ,cAAc,CAAC;AAAA,IACnC,QAAQ,QAAQ,UAAU,CAAC;AAAA,EAC7B;AACF;AAEO,IAAM,OAAO,CAAC,cAAqC;AACxD,MAAI,aAAa,SAAS,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,OAAO,QAAQ,SAAS,GAAG;AAC9B,WAAO,UAAU;AAAA,EACnB;AAEA,QAAM,sBAAsB,OAAO,kBAAkB,WAAW,qBAAqB;AACrF,MAAI,QAAQ,MAAM,mBAAmB,GAAG;AACtC,WAAO,UAAU;AAAA,EACnB;AAEA,SAAO,oBAAoB;AAC7B;AAEO,IAAM,0BAA0B,CAAC,OAAmB,SAAyC;AAClG,SAAO,kBAAkB,OAAO,CAAC,OAAO,GAAG,SAAS,IAAI;AAC1D;AAOO,IAAM,oBAAoB,CAAC,OAAmB,cAAsE;AACzH,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,MAAM,MAAM,OAAO,IAAI,CAAC,OAAO,kBAAkB,IAAI,SAAS,CAAC,EAAE,OAAO,QAAQ,SAAS,CAAC;AAC1G;AAEO,IAAM,YAAY,CAAC,SAA4B,WAAsD;AAC1G,MAAI,OAAO,WAAW,GAAG;AACvB,WAAO;AAAA,EACT;AAEA,SAAO,GAAG,EAAE,GAAG,SAAS,OAAO,CAAC;AAClC;AAEO,IAAM,qBAAgC;AACtC,IAAM,oBAA+B;AAErC,IAAM,gCAAwD;AAC9D,IAAM,0BAAkD;AAExD,IAAM,YAAY,CAAC,YACxB;AAAA,EACE,QAAQ,MAAM,SAAS;AAAA,IACrB,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,EAAE,CAAC,uBAAuB,GAAG,IAAI;AAAA,EAC/C,CAAC;AACH;AAEK,IAAM,WAAW,CAAC,YACvB;AAAA,EACE,QAAQ,MAAM,SAAS;AAAA,IACrB,MAAM;AAAA,IACN,SAAS;AAAA,IACT,YAAY,EAAE,CAAC,uBAAuB,GAAG,IAAI;AAAA,EAC/C,CAAC;AACH;","names":[]}

package/dist/error.d.ts

@@ -0,0 +1,3 @@
+export declare const isError: (value: any) => value is Error;
+export declare const findInCausalChain: (error: Error, predicate: (error: Error) => boolean) => Error | undefined;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,gCAAW,CAAA;AAE/B,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,KAAG,KAAK,GAAG,SAU9F,CAAA"}

package/dist/error.js

@@ -0,0 +1,18 @@
+// src/error.ts
+import { Objects } from "@bessemer/cornerstone";
+import { isError as _isError } from "lodash-es";
+var isError = _isError;
+var findInCausalChain = (error, predicate) => {
+  if (predicate(error)) {
+    return error;
+  }
+  if (Objects.isPresent(error.cause) && error.cause instanceof Error) {
+    return findInCausalChain(error.cause, predicate);
+  }
+  return void 0;
+};
+export {
+  findInCausalChain,
+  isError
+};
+//# sourceMappingURL=error.js.map

package/dist/error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/error.ts"],"sourcesContent":["import { Objects } from '@bessemer/cornerstone'\nimport { isError as _isError } from 'lodash-es'\n\nexport const isError = _isError\n\nexport const findInCausalChain = (error: Error, predicate: (error: Error) => boolean): Error | undefined => {\n  if (predicate(error)) {\n    return error\n  }\n\n  if (Objects.isPresent(error.cause) && error.cause instanceof Error) {\n    return findInCausalChain(error.cause, predicate)\n  }\n\n  return undefined\n}\n"],"mappings":";AAAA,SAAS,eAAe;AACxB,SAAS,WAAW,gBAAgB;AAE7B,IAAM,UAAU;AAEhB,IAAM,oBAAoB,CAAC,OAAc,cAA4D;AAC1G,MAAI,UAAU,KAAK,GAAG;AACpB,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,UAAU,MAAM,KAAK,KAAK,MAAM,iBAAiB,OAAO;AAClE,WAAO,kBAAkB,MAAM,OAAO,SAAS;AAAA,EACjD;AAEA,SAAO;AACT;","names":[]}

package/dist/expression/array-expression.d.ts

@@ -0,0 +1,14 @@
+import { Expression } from '@bessemer/cornerstone/expression';
+export declare const ConcatenateExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<unknown[], [operands: Expression<unknown[]>[]], Expression<unknown[]> & {
+    operands: Expression<unknown[]>[];
+}>;
+export declare const concatenate: (operands: Expression<unknown[]>[]) => Expression<unknown[]> & {
+    operands: Expression<unknown[]>[];
+};
+export declare const FirstExpression: import("@bessemer/cornerstone/expression").ExpressionDefinition<unknown[] | undefined, [operands: Expression<unknown[]>[]], Expression<unknown[] | undefined> & {
+    operands: Expression<unknown[]>[];
+}>;
+export declare const first: (operands: Expression<unknown[]>[]) => Expression<unknown[] | undefined> & {
+    operands: Expression<unknown[]>[];
+};
+//# sourceMappingURL=array-expression.d.ts.map

package/dist/expression/array-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-expression.d.ts","sourceRoot":"","sources":["../../src/expression/array-expression.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAG7D,eAAO,MAAM,qBAAqB;;EAShC,CAAA;AAEF,eAAO,MAAM,WAAW;;CAAgC,CAAA;AAExD,eAAO,MAAM,eAAe;;EAS1B,CAAA;AAEF,eAAO,MAAM,KAAK;;CAA0B,CAAA"}

package/dist/expression/array-expression.js

@@ -0,0 +1,32 @@
+// src/expression/array-expression.ts
+import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+import { Arrays } from "@bessemer/cornerstone";
+var ConcatenateExpression = defineExpression({
+  expressionKey: "Array.Concatenate",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = evaluate(operands).map((it) => evaluate(it));
+    return Arrays.concatenate(values[0], ...Arrays.rest(values));
+  }
+});
+var concatenate = ConcatenateExpression.builder;
+var FirstExpression = defineExpression({
+  expressionKey: "Array.First",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: ({ operands }, evaluate) => {
+    const values = evaluate(operands).map((it) => evaluate(it));
+    return Arrays.first(values);
+  }
+});
+var first = FirstExpression.builder;
+export {
+  ConcatenateExpression,
+  FirstExpression,
+  concatenate,
+  first
+};
+//# sourceMappingURL=array-expression.js.map

package/dist/expression/array-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/array-expression.ts"],"sourcesContent":["import { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { Expression } from '@bessemer/cornerstone/expression'\nimport { Arrays } from '@bessemer/cornerstone'\n\nexport const ConcatenateExpression = defineExpression({\n  expressionKey: 'Array.Concatenate',\n  builder: (operands: Array<Expression<Array<Expression<unknown>>>>) => {\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = evaluate(operands).map((it) => evaluate(it))\n    return Arrays.concatenate(values[0], ...Arrays.rest(values))\n  },\n})\n\nexport const concatenate = ConcatenateExpression.builder\n\nexport const FirstExpression = defineExpression({\n  expressionKey: 'Array.First',\n  builder: (operands: Array<Expression<Array<Expression<unknown>>>>) => {\n    return { operands }\n  },\n  resolver: ({ operands }, evaluate) => {\n    const values = evaluate(operands).map((it) => evaluate(it))\n    return Arrays.first(values)\n  },\n})\n\nexport const first = FirstExpression.builder\n"],"mappings":";AAAA,SAAS,wBAAwB;AAEjC,SAAS,cAAc;AAEhB,IAAM,wBAAwB,iBAAiB;AAAA,EACpD,eAAe;AAAA,EACf,SAAS,CAAC,aAA4D;AACpE,WAAO,EAAE,SAAS;AAAA,EACpB;AAAA,EACA,UAAU,CAAC,EAAE,SAAS,GAAG,aAAa;AACpC,UAAM,SAAS,SAAS,QAAQ,EAAE,IAAI,CAAC,OAAO,SAAS,EAAE,CAAC;AAC1D,WAAO,OAAO,YAAY,OAAO,CAAC,GAAG,GAAG,OAAO,KAAK,MAAM,CAAC;AAAA,EAC7D;AACF,CAAC;AAEM,IAAM,cAAc,sBAAsB;AAE1C,IAAM,kBAAkB,iBAAiB;AAAA,EAC9C,eAAe;AAAA,EACf,SAAS,CAAC,aAA4D;AACpE,WAAO,EAAE,SAAS;AAAA,EACpB;AAAA,EACA,UAAU,CAAC,EAAE,SAAS,GAAG,aAAa;AACpC,UAAM,SAAS,SAAS,QAAQ,EAAE,IAAI,CAAC,OAAO,SAAS,EAAE,CAAC;AAC1D,WAAO,OAAO,MAAM,MAAM;AAAA,EAC5B;AACF,CAAC;AAEM,IAAM,QAAQ,gBAAgB;","names":[]}

package/dist/expression/expression-evaluator.d.ts

@@ -0,0 +1,8 @@
+import { Expression, ExpressionContext, ExpressionDefinition, ExpressionReference } from '@bessemer/cornerstone/expression';
+export declare class ExpressionEvaluator {
+    private readonly expressionDefinitions;
+    constructor(expressionDefinitions: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>>);
+    evaluate<T>(expression: Expression<T>, context: ExpressionContext): T;
+    dereference<ReturnType, ArgumentType extends Array<unknown>>(reference: ExpressionReference<ReturnType, ArgumentType>, ...args: ArgumentType): Expression<ReturnType>;
+}
+//# sourceMappingURL=expression-evaluator.d.ts.map

package/dist/expression/expression-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-evaluator.d.ts","sourceRoot":"","sources":["../../src/expression/expression-evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,mBAAmB,EAAe,MAAM,kCAAkC,CAAA;AAGxI,qBAAa,mBAAmB;IAClB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAArB,qBAAqB,EAAE,KAAK,CAAC,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAErH,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,CAAC;IAUrE,WAAW,CAAC,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACzD,SAAS,EAAE,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,EACxD,GAAG,IAAI,EAAE,YAAY,GACpB,UAAU,CAAC,UAAU,CAAC;CAK1B"}

package/dist/expression/expression-evaluator.js

@@ -0,0 +1,31 @@
+// src/expression/expression-evaluator.ts
+import { Objects, Preconditions } from "@bessemer/cornerstone";
+var ExpressionEvaluator = class {
+  constructor(expressionDefinitions) {
+    this.expressionDefinitions = expressionDefinitions;
+  }
+  evaluate(expression, context) {
+    if (isValue(expression)) {
+      return expression;
+    }
+    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey);
+    Preconditions.isPresent(matchingExpressionDefinition);
+    return matchingExpressionDefinition.resolver(expression, (expression2) => this.evaluate(expression2, context), context);
+  }
+  dereference(reference, ...args) {
+    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === reference.expressionKey);
+    Preconditions.isPresent(matchingExpressionDefinition, () => `Unable to find Expression Definition for type: ${reference.expressionKey}`);
+    return matchingExpressionDefinition.builder(...args);
+  }
+};
+var isValue = (expression) => {
+  if (!Objects.isObject(expression)) {
+    return true;
+  }
+  const result = expression.expressionKey === void 0;
+  return result;
+};
+export {
+  ExpressionEvaluator
+};
+//# sourceMappingURL=expression-evaluator.js.map

package/dist/expression/expression-evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/expression-evaluator.ts"],"sourcesContent":["import { Expression, ExpressionContext, ExpressionDefinition, ExpressionReference, IExpression } from '@bessemer/cornerstone/expression'\nimport { Objects, Preconditions } from '@bessemer/cornerstone'\n\nexport class ExpressionEvaluator {\n  constructor(private readonly expressionDefinitions: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>>) {}\n\n  evaluate<T>(expression: Expression<T>, context: ExpressionContext): T {\n    if (isValue(expression)) {\n      return expression\n    }\n\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === expression.expressionKey)\n    Preconditions.isPresent(matchingExpressionDefinition)\n    return matchingExpressionDefinition.resolver(expression, (expression) => this.evaluate(expression, context), context) as T\n  }\n\n  dereference<ReturnType, ArgumentType extends Array<unknown>>(\n    reference: ExpressionReference<ReturnType, ArgumentType>,\n    ...args: ArgumentType\n  ): Expression<ReturnType> {\n    const matchingExpressionDefinition = this.expressionDefinitions.find((it) => it.expressionKey === reference.expressionKey)\n    Preconditions.isPresent(matchingExpressionDefinition, () => `Unable to find Expression Definition for type: ${reference.expressionKey}`)\n    return matchingExpressionDefinition.builder(...args)\n  }\n}\n\nconst isValue = <T>(expression: Expression<T>): expression is T => {\n  if (!Objects.isObject(expression)) {\n    return true\n  }\n\n  const result = (expression as IExpression<T>).expressionKey === undefined\n  return result\n}\n"],"mappings":";AACA,SAAS,SAAS,qBAAqB;AAEhC,IAAM,sBAAN,MAA0B;AAAA,EAC/B,YAA6B,uBAA0F;AAA1F;AAAA,EAA2F;AAAA,EAExH,SAAY,YAA2B,SAA+B;AACpE,QAAI,QAAQ,UAAU,GAAG;AACvB,aAAO;AAAA,IACT;AAEA,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,WAAW,aAAa;AAC1H,kBAAc,UAAU,4BAA4B;AACpD,WAAO,6BAA6B,SAAS,YAAY,CAACA,gBAAe,KAAK,SAASA,aAAY,OAAO,GAAG,OAAO;AAAA,EACtH;AAAA,EAEA,YACE,cACG,MACqB;AACxB,UAAM,+BAA+B,KAAK,sBAAsB,KAAK,CAAC,OAAO,GAAG,kBAAkB,UAAU,aAAa;AACzH,kBAAc,UAAU,8BAA8B,MAAM,kDAAkD,UAAU,aAAa,EAAE;AACvI,WAAO,6BAA6B,QAAQ,GAAG,IAAI;AAAA,EACrD;AACF;AAEA,IAAM,UAAU,CAAI,eAA+C;AACjE,MAAI,CAAC,QAAQ,SAAS,UAAU,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,SAAU,WAA8B,kBAAkB;AAChE,SAAO;AACT;","names":["expression"]}

package/dist/expression/expression.d.ts

@@ -0,0 +1,54 @@
+import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionReference, ExpressionVariable, ParameterizedVariable } from '@bessemer/cornerstone/expression';
+import { Signatures } from '@bessemer/cornerstone';
+import { Signable } from '@bessemer/cornerstone/signature';
+import { UnknownRecord } from 'type-fest';
+export declare const evaluate: <T>(expression: Expression<T>, context: ExpressionContext) => T;
+export declare const evaluateDefault: <T>(expression: Expression<T>) => T;
+export declare const evaluator: (context: ExpressionContext) => EvaluateExpression;
+export declare const defaultEvaluator: () => EvaluateExpression;
+export declare const defaultContext: () => ExpressionContext;
+export declare const dereference: <ReturnType, ArgumentType extends Array<unknown>>(reference: ExpressionReference<ReturnType, ArgumentType>, ...args: ArgumentType) => Expression<ReturnType>;
+export declare const parameterizedVariable: <ValueType, ParameterType extends Array<Signable>>(name: string) => ParameterizedVariable<ValueType, ParameterType>;
+export declare const buildVariable: <T>(variable: ExpressionVariable<T>, value: T) => UnknownRecord;
+export declare const reference: <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>) => ExpressionReference<ReturnType, ArgumentType>;
+export declare const ValueExpression: ExpressionDefinition<unknown, [value: unknown], {
+    value: unknown;
+}>;
+export declare const value: <T>(value: T) => Expression<T>;
+export declare const VariableExpression: ExpressionDefinition<{}, [name: string], Expression<{}> & {
+    name: string;
+}>;
+export declare const variable: <T>(name: string) => ExpressionVariable<T>;
+export declare const NotExpression: ExpressionDefinition<boolean, [value: Expression<boolean>], Expression<boolean> & {
+    value: Expression<boolean>;
+}>;
+export declare const not: (value: Expression<boolean>) => Expression<boolean> & {
+    value: Expression<boolean>;
+};
+export declare const AndExpression: ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
+    operands: Expression<boolean>[];
+}>;
+export declare const and: (operands: Expression<boolean>[]) => Expression<boolean> & {
+    operands: Expression<boolean>[];
+};
+export declare const OrExpression: ExpressionDefinition<boolean, [operands: Expression<boolean>[]], Expression<boolean> & {
+    operands: Expression<boolean>[];
+}>;
+export declare const or: (operands: Expression<boolean>[]) => Expression<boolean> & {
+    operands: Expression<boolean>[];
+};
+export declare const EqualsExpression: ExpressionDefinition<boolean, [operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
+    operands: Expression<Signatures.Signable>[];
+}>;
+export declare const equals: (operands: Expression<Signatures.Signable>[]) => Expression<boolean> & {
+    operands: Expression<Signatures.Signable>[];
+};
+export declare const ContainsExpression: ExpressionDefinition<boolean, [collection: Expression<Signatures.Signable[]>, operands: Expression<Signatures.Signable>[]], Expression<boolean> & {
+    collection: Expression<Signatures.Signable[]>;
+    operands: Expression<Signatures.Signable>[];
+}>;
+export declare const contains: (collection: Expression<Signatures.Signable[]>, operands: Expression<Signatures.Signable>[]) => Expression<boolean> & {
+    collection: Expression<Signatures.Signable[]>;
+    operands: Expression<Signatures.Signable>[];
+};
+//# sourceMappingURL=expression.d.ts.map

package/dist/expression/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/expression/expression.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,kBAAkB,EAClB,UAAU,EACV,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAElB,qBAAqB,EAEtB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAkC,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,iBAAiB,KAAG,CAEnF,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,CAAC,CAAC,KAAG,CAE9D,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,SAAS,iBAAiB,KAAG,kBAEtD,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,kBAEnC,CAAA;AAED,eAAO,MAAM,cAAc,QAAO,iBAEjC,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EACzE,WAAW,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,EACxD,GAAG,MAAM,YAAY,KACpB,UAAU,CAAC,UAAU,CAEvB,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,EAAE,aAAa,SAAS,KAAK,CAAC,QAAQ,CAAC,EACpF,MAAM,MAAM,KACX,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAOhD,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,UAAU,kBAAkB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAG,aAE5E,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,UAAU,CAAC,EACtH,sBAAsB,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,cAAc,CAAC,KACnF,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAE9C,CAAA;AAED,eAAO,MAAM,eAAe;;EAQ1B,CAAA;AAEF,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,UAAU,CAAC,CAAC,CAAoD,CAAA;AAEpG,eAAO,MAAM,kBAAkB;;EAU7B,CAAA;AAEF,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,MAAM,MAAM,KAAG,kBAAkB,CAAC,CAAC,CAA8D,CAAA;AAE7H,eAAO,MAAM,aAAa;;EAQxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,aAAa;;EAUxB,CAAA;AAEF,eAAO,MAAM,GAAG;;CAAwB,CAAA;AAExC,eAAO,MAAM,YAAY;;EAUvB,CAAA;AAEF,eAAO,MAAM,EAAE;;CAAuB,CAAA;AAEtC,eAAO,MAAM,gBAAgB;;EAe3B,CAAA;AAEF,eAAO,MAAM,MAAM;;CAA2B,CAAA;AAE9C,eAAO,MAAM,kBAAkB;;;EAU7B,CAAA;AAEF,eAAO,MAAM,QAAQ;;;CAA6B,CAAA"}

package/dist/expression/expression.js

@@ -0,0 +1,173 @@
+// src/expression/expression.ts
+import { ExpressionEvaluator } from "@bessemer/cornerstone/expression/expression-evaluator";
+import {
+  ArrayExpressions,
+  NumericExpressions,
+  StringExpressions
+} from "@bessemer/cornerstone/expression";
+import { Arrays, Objects, Preconditions, Signatures } from "@bessemer/cornerstone";
+import { defineExpression } from "@bessemer/cornerstone/expression/internal";
+var evaluate = (expression, context) => {
+  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context);
+};
+var evaluateDefault = (expression) => {
+  return evaluate(expression, defaultContext());
+};
+var evaluator = (context) => {
+  return (it) => evaluate(it, context);
+};
+var defaultEvaluator = () => {
+  return evaluator(defaultContext());
+};
+var defaultContext = () => {
+  return { variables: {} };
+};
+var dereference = (reference2, ...args) => {
+  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).dereference(reference2, ...args);
+};
+var parameterizedVariable = (name) => {
+  return {
+    apply(...parameters) {
+      const parameterString = parameters.map(Signatures.sign).join(".");
+      return variable(`${name}.${parameterString}`);
+    }
+  };
+};
+var buildVariable = (variable2, value2) => {
+  return { [variable2.name]: value2 };
+};
+var reference = (expressionDefinition) => {
+  return { expressionKey: expressionDefinition.expressionKey };
+};
+var ValueExpression = defineExpression({
+  expressionKey: "Value",
+  builder: (value2) => {
+    return { value: value2 };
+  },
+  resolver: ({ value: value2 }, evaluate2, context) => {
+    return value2;
+  }
+});
+var value = (value2) => ValueExpression.builder(value2);
+var VariableExpression = defineExpression({
+  expressionKey: "Variable",
+  builder: (name) => {
+    return { name };
+  },
+  resolver: ({ name }, evaluate2, context) => {
+    const value2 = context.variables[name];
+    Preconditions.isPresent(value2);
+    return value2;
+  }
+});
+var variable = (name) => VariableExpression.builder(name);
+var NotExpression = defineExpression({
+  expressionKey: "Not",
+  builder: (value2) => {
+    return { value: value2 };
+  },
+  resolver: (expression, evaluate2) => {
+    return !evaluate2(expression.value);
+  }
+});
+var not = NotExpression.builder;
+var AndExpression = defineExpression({
+  expressionKey: "And",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate2) => {
+    const values = expression.operands.map((it) => evaluate2(it));
+    const falseValue = values.find((it) => !it);
+    return Objects.isNil(falseValue);
+  }
+});
+var and = AndExpression.builder;
+var OrExpression = defineExpression({
+  expressionKey: "Or",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate2) => {
+    const values = expression.operands.map((it) => evaluate2(it));
+    const trueValue = values.find((it) => it);
+    return Objects.isPresent(trueValue);
+  }
+});
+var or = OrExpression.builder;
+var EqualsExpression = defineExpression({
+  expressionKey: "Equals",
+  builder: (operands) => {
+    return { operands };
+  },
+  resolver: (expression, evaluate2) => {
+    const values = expression.operands.map((it) => evaluate2(it)).map(Signatures.sign);
+    if (values.length === 0) {
+      return true;
+    }
+    const first = values[0];
+    return values.every((val) => val === first);
+  }
+});
+var equals = EqualsExpression.builder;
+var ContainsExpression = defineExpression({
+  expressionKey: "Contains",
+  builder: (collection, operands) => {
+    return { collection, operands };
+  },
+  resolver: (expression, evaluate2) => {
+    const collection = evaluate2(expression.collection);
+    const values = expression.operands.map((it) => evaluate2(it));
+    return Arrays.containsAll(collection, values);
+  }
+});
+var contains = ContainsExpression.builder;
+var DEFAULT_EXPRESSION_DEFINITIONS = [
+  ValueExpression,
+  VariableExpression,
+  AndExpression,
+  OrExpression,
+  ContainsExpression,
+  EqualsExpression,
+  NumericExpressions.SumExpression,
+  NumericExpressions.MultiplyExpression,
+  NumericExpressions.GreaterThanExpression,
+  NumericExpressions.LessThanExpression,
+  NumericExpressions.FloorExpression,
+  NumericExpressions.CeilingExpression,
+  NumericExpressions.BoundsExpression,
+  NumericExpressions.RoundExpression,
+  NumericExpressions.MaxExpression,
+  NumericExpressions.MinExpression,
+  StringExpressions.ConcatenateExpression,
+  StringExpressions.SubstringExpression,
+  StringExpressions.UppercaseExpression,
+  ArrayExpressions.ConcatenateExpression,
+  ArrayExpressions.FirstExpression
+];
+export {
+  AndExpression,
+  ContainsExpression,
+  EqualsExpression,
+  NotExpression,
+  OrExpression,
+  ValueExpression,
+  VariableExpression,
+  and,
+  buildVariable,
+  contains,
+  defaultContext,
+  defaultEvaluator,
+  dereference,
+  equals,
+  evaluate,
+  evaluateDefault,
+  evaluator,
+  not,
+  or,
+  parameterizedVariable,
+  reference,
+  value,
+  variable
+};
+//# sourceMappingURL=expression.js.map

package/dist/expression/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/expression.ts"],"sourcesContent":["import { ExpressionEvaluator } from '@bessemer/cornerstone/expression/expression-evaluator'\nimport {\n  ArrayExpressions,\n  EvaluateExpression,\n  Expression,\n  ExpressionContext,\n  ExpressionDefinition,\n  ExpressionReference,\n  ExpressionVariable,\n  NumericExpressions,\n  ParameterizedVariable,\n  StringExpressions,\n} from '@bessemer/cornerstone/expression'\nimport { Arrays, Objects, Preconditions, Signatures } from '@bessemer/cornerstone'\nimport { Signable } from '@bessemer/cornerstone/signature'\nimport { defineExpression } from '@bessemer/cornerstone/expression/internal'\nimport { UnknownRecord } from 'type-fest'\n\nexport const evaluate = <T>(expression: Expression<T>, context: ExpressionContext): T => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).evaluate(expression, context)\n}\n\nexport const evaluateDefault = <T>(expression: Expression<T>): T => {\n  return evaluate(expression, defaultContext())\n}\n\nexport const evaluator = (context: ExpressionContext): EvaluateExpression => {\n  return (it) => evaluate(it, context)\n}\n\nexport const defaultEvaluator = (): EvaluateExpression => {\n  return evaluator(defaultContext())\n}\n\nexport const defaultContext = (): ExpressionContext => {\n  return { variables: {} }\n}\n\nexport const dereference = <ReturnType, ArgumentType extends Array<unknown>>(\n  reference: ExpressionReference<ReturnType, ArgumentType>,\n  ...args: ArgumentType\n): Expression<ReturnType> => {\n  return new ExpressionEvaluator(DEFAULT_EXPRESSION_DEFINITIONS).dereference(reference, ...args)\n}\n\nexport const parameterizedVariable = <ValueType, ParameterType extends Array<Signable>>(\n  name: string\n): ParameterizedVariable<ValueType, ParameterType> => {\n  return {\n    apply(...parameters: ParameterType): ExpressionVariable<ValueType> {\n      const parameterString = parameters.map(Signatures.sign).join('.')\n      return variable(`${name}.${parameterString}`)\n    },\n  }\n}\n\nexport const buildVariable = <T>(variable: ExpressionVariable<T>, value: T): UnknownRecord => {\n  return { [variable.name]: value }\n}\n\nexport const reference = <ReturnType, ArgumentType extends Array<unknown>, ExpressionType extends Expression<ReturnType>>(\n  expressionDefinition: ExpressionDefinition<ReturnType, ArgumentType, ExpressionType>\n): ExpressionReference<ReturnType, ArgumentType> => {\n  return { expressionKey: expressionDefinition.expressionKey }\n}\n\nexport const ValueExpression = defineExpression({\n  expressionKey: 'Value',\n  builder: (value: unknown) => {\n    return { value }\n  },\n  resolver: ({ value }, evaluate, context) => {\n    return value\n  },\n})\n\nexport const value = <T>(value: T): Expression<T> => ValueExpression.builder(value) as Expression<T>\n\nexport const VariableExpression = defineExpression({\n  expressionKey: 'Variable',\n  builder: (name: string) => {\n    return { name }\n  },\n  resolver: ({ name }, evaluate, context) => {\n    const value = context.variables[name]\n    Preconditions.isPresent(value)\n    return value\n  },\n})\n\nexport const variable = <T>(name: string): ExpressionVariable<T> => VariableExpression.builder(name) as ExpressionVariable<T>\n\nexport const NotExpression = defineExpression({\n  expressionKey: 'Not',\n  builder: (value: Expression<boolean>) => {\n    return { value }\n  },\n  resolver: (expression, evaluate) => {\n    return !evaluate(expression.value)\n  },\n})\n\nexport const not = NotExpression.builder\n\nexport const AndExpression = defineExpression({\n  expressionKey: 'And',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const falseValue = values.find((it) => !it)\n    return Objects.isNil(falseValue)\n  },\n})\n\nexport const and = AndExpression.builder\n\nexport const OrExpression = defineExpression({\n  expressionKey: 'Or',\n  builder: (operands: Array<Expression<boolean>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it))\n    const trueValue = values.find((it) => it)\n    return Objects.isPresent(trueValue)\n  },\n})\n\nexport const or = OrExpression.builder\n\nexport const EqualsExpression = defineExpression({\n  expressionKey: 'Equals',\n  builder: (operands: Array<Expression<Signable>>) => {\n    return { operands }\n  },\n  resolver: (expression, evaluate) => {\n    const values = expression.operands.map((it) => evaluate(it)).map(Signatures.sign)\n\n    if (values.length === 0) {\n      return true\n    }\n\n    const first = values[0]\n    return values.every((val) => val === first)\n  },\n})\n\nexport const equals = EqualsExpression.builder\n\nexport const ContainsExpression = defineExpression({\n  expressionKey: 'Contains',\n  builder: (collection: Expression<Array<Signable>>, operands: Array<Expression<Signable>>) => {\n    return { collection, operands }\n  },\n  resolver: (expression, evaluate) => {\n    const collection = evaluate(expression.collection)\n    const values = expression.operands.map((it) => evaluate(it))\n    return Arrays.containsAll(collection, values)\n  },\n})\n\nexport const contains = ContainsExpression.builder\n\nconst DEFAULT_EXPRESSION_DEFINITIONS: Array<ExpressionDefinition<unknown, Array<any>, Expression<any>>> = [\n  ValueExpression,\n  VariableExpression,\n  AndExpression,\n  OrExpression,\n  ContainsExpression,\n  EqualsExpression,\n  NumericExpressions.SumExpression,\n  NumericExpressions.MultiplyExpression,\n  NumericExpressions.GreaterThanExpression,\n  NumericExpressions.LessThanExpression,\n  NumericExpressions.FloorExpression,\n  NumericExpressions.CeilingExpression,\n  NumericExpressions.BoundsExpression,\n  NumericExpressions.RoundExpression,\n  NumericExpressions.MaxExpression,\n  NumericExpressions.MinExpression,\n  StringExpressions.ConcatenateExpression,\n  StringExpressions.SubstringExpression,\n  StringExpressions.UppercaseExpression,\n  ArrayExpressions.ConcatenateExpression,\n  ArrayExpressions.FirstExpression,\n]\n"],"mappings":"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","names":["reference","variable","value","evaluate"]}

package/dist/expression/internal.d.ts

@@ -0,0 +1,10 @@
+import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionKey, IExpression } from '@bessemer/cornerstone/expression';
+import { UnknownRecord } from 'type-fest';
+export declare const defineExpression: <ReturnType, ArgumentType extends Array<unknown>, PayloadType extends UnknownRecord>(options: {
+    expressionKey: ExpressionKey<ReturnType, ArgumentType>;
+    builder: (...parameters: ArgumentType) => PayloadType;
+    resolver: (expression: PayloadType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType;
+}) => ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType>;
+export declare const isType: <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(expression: Expression<ReturnValue>, expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>) => expression is ReturnType<(typeof expressionDefinition)["builder"]>;
+export declare const isExpression: <T>(expression: Expression<any>) => expression is IExpression<T>;
+//# sourceMappingURL=internal.d.ts.map

package/dist/expression/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/expression/internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAEtJ,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,eAAO,MAAM,gBAAgB,GAAI,UAAU,EAAE,YAAY,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,SAAS,aAAa,EAAE,SAAS;IAC5H,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACtD,OAAO,EAAE,CAAC,GAAG,UAAU,EAAE,YAAY,KAAK,WAAW,CAAA;IACrD,QAAQ,EAAE,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,KAAK,UAAU,CAAA;CAC5G,KAAG,oBAAoB,CAAC,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,WAAW,CAUtF,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,WAAW,EAAE,YAAY,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,cAAc,SAAS,UAAU,CAAC,WAAW,CAAC,EACjH,YAAY,UAAU,CAAC,WAAW,CAAC,EACnC,sBAAsB,oBAAoB,CAAC,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,KACpF,UAAU,IAAI,UAAU,CAAC,CAAA,OAAO,oBAAoB,EAAC,SAAS,CAAC,CAMjE,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,YAAY,UAAU,CAAC,GAAG,CAAC,KAAG,UAAU,IAAI,WAAW,CAAC,CAAC,CAExF,CAAA"}

package/dist/expression/internal.js

@@ -0,0 +1,28 @@
+// src/expression/internal.ts
+import { Objects } from "@bessemer/cornerstone";
+var defineExpression = (options) => {
+  return {
+    expressionKey: options.expressionKey,
+    builder: (...parameters) => {
+      return { expressionKey: options.expressionKey, ...options.builder(...parameters) };
+    },
+    resolver: (expression, evaluate, context) => {
+      return options.resolver(expression, evaluate, context);
+    }
+  };
+};
+var isType = (expression, expressionDefinition) => {
+  if (!isExpression(expression)) {
+    return false;
+  }
+  return expression.expressionKey === expressionDefinition.expressionKey;
+};
+var isExpression = (expression) => {
+  return Objects.isObject(expression) && "expressionKey" in expression;
+};
+export {
+  defineExpression,
+  isExpression,
+  isType
+};
+//# sourceMappingURL=internal.js.map

package/dist/expression/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/expression/internal.ts"],"sourcesContent":["import { EvaluateExpression, Expression, ExpressionContext, ExpressionDefinition, ExpressionKey, IExpression } from '@bessemer/cornerstone/expression'\nimport { Objects } from '@bessemer/cornerstone'\nimport { UnknownRecord } from 'type-fest'\n\nexport const defineExpression = <ReturnType, ArgumentType extends Array<unknown>, PayloadType extends UnknownRecord>(options: {\n  expressionKey: ExpressionKey<ReturnType, ArgumentType>\n  builder: (...parameters: ArgumentType) => PayloadType\n  resolver: (expression: PayloadType, evaluate: EvaluateExpression, context: ExpressionContext) => ReturnType\n}): ExpressionDefinition<ReturnType, ArgumentType, Expression<ReturnType> & PayloadType> => {\n  return {\n    expressionKey: options.expressionKey,\n    builder: (...parameters) => {\n      return { expressionKey: options.expressionKey, ...options.builder(...parameters) }\n    },\n    resolver: (expression, evaluate, context) => {\n      return options.resolver(expression as any, evaluate, context)\n    },\n  }\n}\n\nexport const isType = <ReturnValue, ArgumentType extends Array<any>, ExpressionType extends Expression<ReturnValue>>(\n  expression: Expression<ReturnValue>,\n  expressionDefinition: ExpressionDefinition<ReturnValue, ArgumentType, ExpressionType>\n): expression is ReturnType<typeof expressionDefinition['builder']> => {\n  if (!isExpression(expression)) {\n    return false\n  }\n\n  return expression.expressionKey === expressionDefinition.expressionKey\n}\n\nexport const isExpression = <T>(expression: Expression<any>): expression is IExpression<T> => {\n  return Objects.isObject(expression) && 'expressionKey' in expression\n}\n"],"mappings":";AACA,SAAS,eAAe;AAGjB,IAAM,mBAAmB,CAAqF,YAIzB;AAC1F,SAAO;AAAA,IACL,eAAe,QAAQ;AAAA,IACvB,SAAS,IAAI,eAAe;AAC1B,aAAO,EAAE,eAAe,QAAQ,eAAe,GAAG,QAAQ,QAAQ,GAAG,UAAU,EAAE;AAAA,IACnF;AAAA,IACA,UAAU,CAAC,YAAY,UAAU,YAAY;AAC3C,aAAO,QAAQ,SAAS,YAAmB,UAAU,OAAO;AAAA,IAC9D;AAAA,EACF;AACF;AAEO,IAAM,SAAS,CACpB,YACA,yBACqE;AACrE,MAAI,CAAC,aAAa,UAAU,GAAG;AAC7B,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,kBAAkB,qBAAqB;AAC3D;AAEO,IAAM,eAAe,CAAI,eAA8D;AAC5F,SAAO,QAAQ,SAAS,UAAU,KAAK,mBAAmB;AAC5D;","names":[]}