@nira-opencrvs/toolkit 1.9.11-rc.39d8d68

package/dist/commons/notification/index.d.ts

@@ -0,0 +1,2 @@
+export * from './UserNotifications';
+//# sourceMappingURL=index.d.ts.map

package/dist/conditionals/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../commons/conditionals';
+//# sourceMappingURL=index.d.ts.map

package/dist/conditionals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/conditionals/index.ts"],"names":[],"mappings":"AAUA,cAAc,gCAAgC,CAAA"}

package/dist/conditionals/index.js

@@ -0,0 +1,689 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/conditionals/index.ts
+var conditionals_exports = {};
+__export(conditionals_exports, {
+  alwaysTrue: () => alwaysTrue,
+  and: () => and,
+  createFieldConditionals: () => createFieldConditionals,
+  defineConditional: () => defineConditional,
+  defineFormConditional: () => defineFormConditional,
+  isEventFieldReference: () => isEventFieldReference,
+  isFieldReference: () => isFieldReference,
+  never: () => never,
+  not: () => not,
+  now: () => now,
+  or: () => or,
+  user: () => user
+});
+module.exports = __toCommonJS(conditionals_exports);
+
+// ../commons/src/conditionals/conditionals.ts
+var objectHash = __toESM(require("object-hash"));
+
+// ../commons/src/events/serializers/user/serializer.ts
+var import_zod = require("zod");
+var SerializedUserField = import_zod.z.object({
+  $userField: import_zod.z.enum([
+    "id",
+    "name",
+    "role",
+    "fullHonorificName",
+    "device",
+    "firstname",
+    "middlename",
+    "surname",
+    "district",
+    "province",
+    "primaryOfficeId"
+  ]),
+  $location: import_zod.z.string().optional()
+});
+function userSerializer(userField) {
+  return {
+    $userField: userField,
+    locationLevel(adminLevelId) {
+      return {
+        $userField: this.$userField,
+        $location: adminLevelId
+      };
+    },
+    toJSON() {
+      return {
+        $userField: userField
+      };
+    }
+  };
+}
+
+// ../commons/src/utils.ts
+var z2 = __toESM(require("zod"));
+var _ = __toESM(require("lodash"));
+var FullNameV1 = z2.array(
+  z2.object({
+    use: z2.string(),
+    family: z2.string(),
+    given: z2.array(z2.string())
+  })
+);
+function omitKeyDeep(obj, keyToRemove) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => omitKeyDeep(item, keyToRemove));
+  }
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  const newObj = {};
+  for (const key of Object.keys(obj)) {
+    if (key !== keyToRemove) {
+      newObj[key] = omitKeyDeep(obj[key], keyToRemove);
+    }
+  }
+  return newObj;
+}
+
+// ../commons/src/events/serializers/date/serializer.ts
+var import_zod2 = require("zod");
+var SerializedNowDateTime = import_zod2.z.object({
+  $$now: import_zod2.z.literal(true)
+});
+function todayDateTimeValueSerializer() {
+  return { $$now: true };
+}
+
+// ../commons/src/conditionals/conditionals.ts
+function defineConditional(schema) {
+  const schemaWithooutIDRef = omitKeyDeep(schema, "$id");
+  return {
+    $id: `https://opencrvs.org/conditionals/${objectHash.sha1(schemaWithooutIDRef)}`,
+    ...schemaWithooutIDRef
+  };
+}
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
+function alwaysTrue() {
+  return {};
+}
+function and(...conditions) {
+  return defineConditional({
+    type: "object",
+    allOf: conditions,
+    required: []
+  });
+}
+function or(...conditions) {
+  return defineConditional({
+    type: "object",
+    anyOf: conditions,
+    required: []
+  });
+}
+function not(condition) {
+  return defineConditional({
+    type: "object",
+    not: condition,
+    required: []
+  });
+}
+function never() {
+  return not(alwaysTrue());
+}
+function jsonFieldPath(field) {
+  return [field.$$field, ...field.$$subfield].join("/");
+}
+function wrapToPath(condition, path) {
+  if (path.length === 0) {
+    return condition;
+  }
+  return path.reduceRight((conditionNow, part) => {
+    return {
+      type: "object",
+      properties: {
+        [part]: conditionNow
+      },
+      required: [part]
+    };
+  }, condition);
+}
+function wrapToPathOptional(condition, path) {
+  if (path.length === 0) {
+    return condition;
+  }
+  return path.reduceRight((conditionNow, part) => {
+    return {
+      type: "object",
+      properties: { [part]: conditionNow }
+    };
+  }, condition);
+}
+var now = Object.assign(todayDateTimeValueSerializer, {});
+var user = Object.assign(userSerializer, {
+  hasScope: (scope) => defineConditional({
+    type: "object",
+    properties: {
+      $user: {
+        type: "object",
+        required: ["scope"],
+        properties: {
+          scope: {
+            type: "array",
+            contains: {
+              type: "string",
+              const: scope
+            }
+          }
+        }
+      }
+    },
+    required: ["$user"]
+  }),
+  hasRole: (role) => defineConditional({
+    type: "object",
+    properties: {
+      $user: {
+        type: "object",
+        required: ["role"],
+        properties: {
+          role: {
+            type: "string",
+            const: role
+          }
+        }
+      }
+    },
+    required: ["$user"]
+  }),
+  isOnline: () => defineConditional({
+    type: "object",
+    properties: {
+      $online: {
+        type: "boolean",
+        const: true
+      }
+    },
+    required: ["$online"]
+  }),
+  locationLevel: (adminLevelId) => ({
+    $user: {
+      $location: adminLevelId
+    }
+  })
+});
+function isFieldReference(value) {
+  return typeof value === "object" && value !== null && "$$field" in value;
+}
+function isEventFieldReference(value) {
+  return typeof value === "object" && value !== null && "$$event" in value;
+}
+function getDateRangeToFieldReference(field, comparedField, clause) {
+  return {
+    type: "object",
+    properties: {
+      [field.$$field]: wrapToPath(
+        {
+          type: "string",
+          format: "date",
+          [clause]: {
+            $data: `${field.$$subfield.length + 1}/${jsonFieldPath(comparedField)}`
+          }
+        },
+        field.$$subfield
+      ),
+      [comparedField.$$field]: wrapToPath(
+        { type: "string", format: "date" },
+        comparedField.$$subfield
+      )
+    },
+    required: [field.$$field]
+  };
+}
+function getDayRangeToFieldReference(field, comparedField, days, clause) {
+  return {
+    type: "object",
+    properties: {
+      [field.$$field]: wrapToPath(
+        {
+          type: "string",
+          format: "date",
+          daysFromDate: {
+            referenceDate: {
+              $data: `${field.$$subfield.length + 1}/${jsonFieldPath(
+                comparedField
+              )}`
+            },
+            clause,
+            days
+          }
+        },
+        field.$$subfield
+      ),
+      [comparedField.$$field]: wrapToPath(
+        { type: "string", format: "date" },
+        comparedField.$$subfield
+      )
+    },
+    required: [field.$$field]
+  };
+}
+function defineComparison(field, value, keyword) {
+  if (isFieldReference(value)) {
+    const comparedField = value;
+    return defineFormConditional({
+      type: "object",
+      properties: {
+        [field.$$field]: wrapToPath(
+          {
+            type: ["number"],
+            [keyword]: {
+              $data: `${field.$$subfield.length + 1}/${jsonFieldPath(comparedField)}`
+            }
+          },
+          field.$$subfield
+        ),
+        [comparedField.$$field]: wrapToPath(
+          { type: "number" },
+          comparedField.$$subfield
+        )
+      },
+      required: [field.$$field]
+    });
+  }
+  return defineFormConditional({
+    type: "object",
+    properties: {
+      [field.$$field]: wrapToPath(
+        { type: "number", [keyword]: value },
+        field.$$subfield
+      )
+    },
+    required: [field.$$field]
+  });
+}
+function createFieldConditionals(fieldId) {
+  const getDayRange = (field, days, clause, referenceDate) => ({
+    type: "object",
+    properties: {
+      [field.$$field]: wrapToPath(
+        {
+          type: "string",
+          format: "date",
+          daysFromDate: {
+            days,
+            clause,
+            referenceDate
+          }
+        },
+        field.$$subfield
+      )
+    },
+    required: [field.$$field]
+  });
+  const getDateRange = (field, date, clause) => ({
+    type: "object",
+    properties: {
+      [field.$$field]: wrapToPath(
+        {
+          type: "string",
+          format: "date",
+          [clause]: date
+        },
+        field.$$subfield
+      )
+    },
+    required: [field.$$field]
+  });
+  return {
+    /**
+     * @private Internal property used for field reference tracking.
+     */
+    $$field: fieldId,
+    /**
+     * @private Internal property used for solving a object path within field's value
+     */
+    $$subfield: [],
+    get(fieldPath) {
+      return {
+        ...this,
+        $$subfield: fieldPath.split(".")
+      };
+    },
+    getByPath(fieldPath) {
+      return {
+        ...this,
+        $$subfield: fieldPath
+      };
+    },
+    asDob() {
+      return this.get("dob");
+    },
+    asAge() {
+      return this.get("age");
+    },
+    isAfter() {
+      return {
+        days: (days) => ({
+          inPast: () => defineFormConditional(getDayRange(this, -days, "after")),
+          inFuture: () => defineFormConditional(getDayRange(this, days, "after")),
+          fromDate: (date) => {
+            if (isFieldReference(date)) {
+              const comparedField = date;
+              return defineFormConditional(
+                getDayRangeToFieldReference(this, comparedField, days, "after")
+              );
+            }
+            return defineFormConditional(getDayRange(this, days, "after", date));
+          },
+          fromNow: () => {
+            return defineFormConditional(getDayRange(this, days, "after"));
+          }
+        }),
+        date: (date) => {
+          if (isFieldReference(date)) {
+            const comparedField = date;
+            return defineFormConditional(
+              getDateRangeToFieldReference(this, comparedField, "formatMinimum")
+            );
+          }
+          return defineFormConditional(
+            getDateRange(this, date, "formatMinimum")
+          );
+        },
+        now: () => defineFormConditional(
+          getDateRange(this, { $data: "/$now" }, "formatMinimum")
+        )
+      };
+    },
+    isBefore() {
+      return {
+        days: (days) => ({
+          inPast: () => defineFormConditional(getDayRange(this, -days, "before")),
+          inFuture: () => defineFormConditional(getDayRange(this, days, "before")),
+          fromDate: (date) => {
+            if (isFieldReference(date)) {
+              const comparedField = date;
+              return defineFormConditional(
+                getDayRangeToFieldReference(
+                  this,
+                  comparedField,
+                  -days,
+                  "before"
+                )
+              );
+            }
+            return defineFormConditional(
+              getDayRange(this, -days, "before", date)
+            );
+          },
+          fromNow: () => {
+            return defineFormConditional(getDayRange(this, -days, "before"));
+          }
+        }),
+        date: (date) => {
+          if (isFieldReference(date)) {
+            const comparedField = date;
+            return defineFormConditional(
+              getDateRangeToFieldReference(this, comparedField, "formatMaximum")
+            );
+          }
+          return defineFormConditional(
+            getDateRange(this, date, "formatMaximum")
+          );
+        },
+        now: () => defineFormConditional(
+          getDateRange(this, { $data: "/$now" }, "formatMaximum")
+        )
+      };
+    },
+    isGreaterThan(value) {
+      return defineComparison(this, value, "exclusiveMinimum");
+    },
+    isLessThan(value) {
+      return defineComparison(this, value, "exclusiveMaximum");
+    },
+    isEqualTo(value) {
+      if (isFieldReference(value)) {
+        const comparedField = value;
+        return defineFormConditional({
+          type: "object",
+          properties: {
+            [this.$$field]: wrapToPath(
+              {
+                type: ["string", "boolean", "number"],
+                const: {
+                  $data: `/$form/${jsonFieldPath(comparedField)}`
+                }
+              },
+              this.$$subfield
+            ),
+            [comparedField.$$field]: wrapToPath(
+              { type: ["string", "boolean", "number"] },
+              comparedField.$$subfield
+            )
+          },
+          required: [this.$$field, comparedField.$$field]
+        });
+      }
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [this.$$field]: wrapToPath(
+            {
+              type: ["string", "boolean", "number"],
+              const: value
+            },
+            this.$$subfield
+          )
+        },
+        required: [this.$$field]
+      });
+    },
+    /**
+     * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
+     * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
+     * @returns whether the field is falsy (undefined, false, null, empty string)
+     *
+     * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
+     *
+     */
+    isFalsy() {
+      const hasSubpath = this.$$subfield.length > 0;
+      const falsyLeaf = {
+        anyOf: [
+          { const: "undefined" },
+          { const: false },
+          { const: null },
+          { const: "" }
+        ]
+      };
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: hasSubpath ? {
+            // either the whole parent is null (treat as undefined),
+            // or the nested leaf is falsy
+            anyOf: [
+              { const: null },
+              wrapToPathOptional(falsyLeaf, this.$$subfield)
+            ]
+          } : falsyLeaf
+        },
+        anyOf: [{ required: [fieldId] }, { not: { required: [fieldId] } }]
+      });
+    },
+    isUndefined() {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              type: "string",
+              enum: ["undefined"]
+            },
+            this.$$subfield
+          )
+        },
+        not: {
+          required: [fieldId]
+        }
+      });
+    },
+    inArray(values) {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              type: "string",
+              enum: values
+            },
+            this.$$subfield
+          )
+        },
+        required: [fieldId]
+      });
+    },
+    isValidEnglishName() {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPathOptional(
+            {
+              type: "string",
+              pattern: "^[\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*( [\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*)*$",
+              description: "Name must contain only letters, numbers, and allowed special characters ('.-). No double spaces."
+            },
+            this.$$subfield
+          )
+        }
+      });
+    },
+    isValidAdministrativeLeafLevel() {
+      const baseCondition = {
+        type: "object",
+        properties: {
+          administrativeArea: {
+            type: "string",
+            isLeafLevelLocation: true
+          }
+        },
+        description: "The provided administrative value should have a value corresponding to the required lowest administrative level when addressType is DOMESTIC"
+      };
+      const conditional = {
+        if: {
+          type: "object",
+          properties: {
+            addressType: { const: "DOMESTIC" }
+          }
+        },
+        then: {
+          ...baseCondition,
+          required: ["administrativeArea"]
+        },
+        else: baseCondition
+      };
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(conditional, this.$$subfield)
+        }
+      });
+    },
+    /**
+     * Checks if the field value matches a given regular expression pattern.
+     * @param pattern - The regular expression pattern to match the field value against.
+     * @returns A JSONSchema conditional that validates the field value against the pattern.
+     */
+    matches(pattern) {
+      return defineFormConditional({
+        type: "object",
+        properties: wrapToPath(
+          {
+            [fieldId]: {
+              type: "string",
+              pattern
+            }
+          },
+          this.$$subfield
+        ),
+        required: [fieldId]
+      });
+    },
+    isBetween(min, max) {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              type: "number",
+              minimum: min,
+              maximum: max
+            },
+            this.$$subfield
+          )
+        },
+        required: [fieldId]
+      });
+    },
+    getId: () => ({ fieldId }),
+    /**
+     * @deprecated
+     * use field(fieldId).get(nestedProperty) instead
+     * with 'and' combinator e.g.
+     * and(
+     *   field('child.name').get('firstname').isEqualTo('John'),
+     *   field('child.name').get('surname').isEqualTo('Doe')
+     * )
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    object: (options) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(options).map(([key, value]) => {
+              return [key, value.properties.$form.properties[key]];
+            })
+          ),
+          required: Object.keys(options)
+        }
+      },
+      required: [fieldId]
+    })
+  };
+}