@haste-health/fhirpath 0.12.2

package/lib/parserv2/types.d.ts

@@ -0,0 +1,75 @@
+export type FunctionAST = {
+    type: "function";
+    functionName: string;
+    parameters: ExpressionAST[];
+};
+export type VariableAST = {
+    type: "variable";
+    value: string;
+};
+export type IdentifierAST = {
+    type: "identifier";
+    value: string;
+};
+export type ThisAST = {
+    type: "this";
+};
+export type IndexAST = {
+    type: "index";
+};
+export type TotalAST = {
+    type: "total";
+};
+export type InvocationAST = FunctionAST | IdentifierAST | ThisAST | IndexAST | TotalAST;
+export type IndexedAST = {
+    type: "indexed";
+    index: ExpressionAST;
+};
+export type NullAST = {
+    type: "literal";
+    literalType: "null";
+    value: null;
+};
+export type BooleanAST = {
+    type: "literal";
+    literalType: "boolean";
+    value: boolean;
+};
+export type NumberAST = {
+    type: "literal";
+    literalType: "number";
+    value: number;
+};
+export type StringAST = {
+    type: "literal";
+    literalType: "string";
+    value: string;
+};
+export type DateAST = {
+    type: "literal";
+    literalType: "date";
+    value: string;
+};
+export type DateTimeAST = {
+    type: "literal";
+    literalType: "datetime";
+    value: string;
+};
+export type TimeAST = {
+    type: "literal";
+    literalType: "time";
+    value: string;
+};
+export type LiteralAST = NullAST | BooleanAST | NumberAST | StringAST | DateAST | DateTimeAST | TimeAST;
+export type TermAST = ExpressionAST | InvocationAST | LiteralAST | VariableAST;
+export type OperationAST = {
+    type: "operation";
+    operator: "*" | "/" | "div" | "mod" | "+" | "-" | "&" | "is" | "as" | "|" | "<=" | "<" | ">" | ">=" | "=" | "~" | "!=" | "!~" | "in" | "contains" | "and" | "or" | "xor" | "implies";
+    left: ExpressionAST;
+    right: ExpressionAST;
+};
+export type SingularExpression = {
+    type: "expression";
+    expression: [TermAST, ...Array<InvocationAST | IndexedAST>];
+};
+export type ExpressionAST = SingularExpression | OperationAST;

package/lib/parserv2/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/parserv2/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/parserv2/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@haste-health/fhirpath",
+  "version": "0.12.2",
+  "homepage": "https://haste.health",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HasteHealth/HasteHealth.git"
+  },
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test": "pnpm node --experimental-vm-modules $(pnpm bin jest)",
+    "publish": "pnpm build && pnpm npm publish --access public --tolerate-republish"
+  },
+  "dependencies": {
+    "@haste-health/meta-value": "workspace:^",
+    "chevrotain": "^11.0.3"
+  },
+  "devDependencies": {
+    "@babel/plugin-syntax-import-attributes": "^7.26.0",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.26.0",
+    "@chevrotain/types": "^11.0.3",
+    "@haste-health/artifacts": "workspace:^",
+    "@haste-health/fhir-types": "workspace:^",
+    "@haste-health/haste-health.fhir.r4.core": "workspace:^",
+    "@haste-health/hl7.fhir.r4.core": "workspace:^",
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.2",
+    "tsx": "4.11.2",
+    "typescript": "5.9.2"
+  },
+  "files": [
+    "lib/**"
+  ],
+  "exports": {
+    ".": "./lib/index.js",
+    "./lib": "./lib/index.js",
+    "./analyze": "./lib/analyze.js",
+    "./lib/analyze": "./lib/analyze.js"
+  }
+}

package/readme.md

@@ -0,0 +1,105 @@
+# FHIRPath
+
+## API
+
+### evaluate
+
+Returns a JS object/primitive based on the evaluation.
+
+```typescript
+evaluate(
+  expression: string,
+  ctx: unknown,
+  options?: Options
+): NonNullable<unknown>[]
+```
+
+### evaluateWithMeta
+
+Returns a @haste-health/meta-value singular value which contains data along with metadata about the evaluation.
+
+```typescript
+function evaluateWithMeta(
+  expression: string,
+  ctx: unknown,
+  options?: Options
+): MetaValueSingular<NonNullable<unknown>>[];
+```
+
+### Arguments
+
+| name               | type                                                             | description                                                                                |
+| ------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| expression         | string                                                           | FHIRPath expression to evaluate.                                                           |
+| ctx                | unknown                                                          | The context which the fhirpath is being evaluated from (sets $this context).               |
+| options            | Object                                                           | Includes variables and metadata deriviation functions.                                     |
+| options.variables  | Object \| Function                                               | If an object is Record\<variableName, variableValue\> else (variableName)=> variableValue. |
+| options.meta       | Object                                                           | MetaInformation used to zip metadata with value. Used in type functions and operators.     |
+| options.meta.type  | string                                                           | Root type for ctx.                                                                         |
+| options.meta.getSD | (fhir_version: FHIRVersion, type: string) => StructureDefinition | Returns a StructureDefinition based on type passed in.                                     |
+
+## Usage
+
+```typescript
+import * as fhirpath from "@haste-health/fhirpath";
+
+// Default returns javascript object.
+expect(fhirpath.evaluate("4 + 5", {})).toEqual([9]);
+expect(fhirpath.evaluate("$this.test + 2 * 4", { test: 4 })).toEqual([12]);
+
+// Evaluation with metavalue return (returns value in addition to meta information.)
+expect(
+  evaluateWithMeta(
+    "$this.name",
+    {
+      resourceType: "Patient",
+      name: [{ given: ["bob"], family: "jameson" }],
+    },
+    {
+      meta: {
+        type: "Patient",
+        getSD: (fhirVersion, type: code) => {
+          const foundSD = sds.find((sd) => sd.type === type);
+          return foundSD;
+        },
+      },
+    }
+  ).map((v) => v.meta()?.type)
+).toEqual(["HumanName"]);
+```
+
+## Operations supported
+
+| Operation                 | Description                                                                                  | Supported |
+| ------------------------- | -------------------------------------------------------------------------------------------- | --------- |
+| + (addition)              | Concatenate strings or add values if numeric.                                                | true      |
+| - (subtraction)           | Subtracts the right operand from the left operand.                                           | true      |
+| as type specifier         | Returns left operand if value is of type specified.                                          | true      |
+| is(type : type specifier) | Filters left operand based on type specifier.                                                | true      |
+| \* (multiplication)       | Multiplies both arguments.                                                                   | true      |
+| / (division)              | Divides the left operand by the right operand                                                | true      |
+| \| (union collections)    | Merge the two collections into a single collection                                           | true      |
+| = (Equals)                | Returns true if the left collection is equal to the right collection                         | true      |
+| != (Not Equals)           | Converse operator of equals returns true if left collection is not equal to right collection | true      |
+
+## Supported Functions
+
+| Name       | Description                                                                                                   | Supported |
+| ---------- | ------------------------------------------------------------------------------------------------------------- | --------- |
+| empty      | Returns true if the input collection is empty ({ }) and false otherwise.                                      | true      |
+| exists     | Returns true if the collection has any elements, and false otherwise.                                         | true      |
+| all        | Returns true if for every element in the input collection, criteria evaluates to true.                        | true      |
+| allTrue    | Takes a collection of Boolean values and returns true if all the items are true.                              | true      |
+| anyTrue    | Takes a collection of Boolean values and returns true if any of the items are true.                           | true      |
+| allFalse   | Takes a collection of Boolean values and returns true if all the items are false.                             | true      |
+| anyFalse   | Takes a collection of Boolean values and returns true if any of the items are false.                          | true      |
+| subsetOf   | Returns true if all items in the input collection are members of the collection passed in.                    | true      |
+| supersetOf | Returns true if all items in the collection passed as the other argument are members of the input collection. | true      |
+| count      | Returns the integer count of the number of items in the input collection.                                     | true      |
+| distinct   | Returns a collection containing only the unique items in the input collection.                                | true      |
+| isDistinct | Returns true if all the items in the input collection are distinct.                                           | true      |
+| where      | Returns a collection containing only those elements in the input collection based on where expression.        | true      |
+| select     | Evaluates the projection expression for each item in the input collection.                                    | true      |
+| repeat     | A version of select that will repeat the projection and add it to the output collection.                      | true      |
+| ofType     | Returns a collection that contains all items in the input collection that are of the given type.              | true      |
+| as         | Returns filter same as ofType used for backwards compatibility.                                               | true      |