@openframe-org/criteria-set-protocol 2.7.7 → 2.7.8-alpha.3

package/dist/v1/functions.d.ts

@@ -0,0 +1,2 @@
+export type HashableParameters = Record<string, string | string[]>;
+export declare const hashParameters: (parameters: HashableParameters) => string;

package/dist/v1/functions.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashParameters = void 0;
+const node_crypto_1 = require("node:crypto");
+const utils_1 = require("./utils");
+const normalizeText = (text) => {
+    return text.normalize("NFC");
+};
+const isValidParametersValue = (value) => {
+    if (typeof value === "string") {
+        return true;
+    }
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (const childValue of value) {
+        if (typeof childValue !== "string") {
+            return false;
+        }
+    }
+    return true;
+};
+const compareUtf8 = (stringA, stringB) => {
+    const bufferA = Buffer.from(stringA, "utf8");
+    const bufferB = Buffer.from(stringB, "utf8");
+    const minimum = Math.min(bufferA.length, bufferB.length);
+    for (let index = 0; index < minimum; index++) {
+        const difference = bufferA[index] - bufferB[index];
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return bufferA.length - bufferB.length;
+};
+const canonicalizeStringParameters = (parameters) => {
+    if ((0, utils_1.isNil)(parameters) || typeof parameters !== "object" || Array.isArray(parameters)) {
+        throw new Error("Cannot canonicalize parameters objects that are not string maps of strings or arrays of strings");
+    }
+    const parts = [];
+    const normalizedParameters = {};
+    for (const [key, value] of Object.entries(parameters)) {
+        normalizedParameters[normalizeText(key)] = value;
+    }
+    for (const key of Object.keys(normalizedParameters).sort(compareUtf8)) {
+        const rawValue = normalizedParameters[key];
+        if (!isValidParametersValue(rawValue)) {
+            throw new Error(`Invalid parameters value for '${key}': ${rawValue}`);
+        }
+        const encodedKey = JSON.stringify(key);
+        let encodedValue;
+        if (typeof rawValue === "string") {
+            encodedValue = JSON.stringify(normalizeText(rawValue));
+        }
+        else {
+            const normalized = rawValue.map(normalizeText).sort(compareUtf8);
+            encodedValue = `[${normalized.map((entry) => JSON.stringify(entry)).join(",")}]`;
+        }
+        parts.push(`${encodedKey}:${encodedValue}`);
+    }
+    return `{${parts.join(",")}}`;
+};
+const hashParameters = (parameters) => {
+    const canonical = canonicalizeStringParameters(parameters);
+    return (0, node_crypto_1.createHash)("sha256").update(canonical, "utf8").digest("hex");
+};
+exports.hashParameters = hashParameters;

package/dist/v1/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./schemas";
 export * from "./services";
 export * from "./types";
+export * from "./functions";
 export * from "./utils";
 export * from "./errors";

package/dist/v1/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./functions"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./errors"), exports);

package/dist/v1/schemas/criteria-tree.d.ts

@@ -2,6 +2,110 @@ import { z } from "zod";
 export declare const criteriaTreeSchema: z.ZodObject<{
     version: z.ZodString;
     revision: z.ZodString;
+    dataMap: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodType<{
+        text: string;
+    } & ({
+        [x: string]: any;
+        value: number;
+        total: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+        type?: "number" | undefined;
+    } | {
+        [x: string]: any;
+        type: "percentage";
+        value: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+    } | {
+        [x: string]: any;
+        type: "boolean";
+        value: boolean;
+    }), unknown, z.core.$ZodTypeInternals<{
+        text: string;
+    } & ({
+        [x: string]: any;
+        value: number;
+        total: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+        type?: "number" | undefined;
+    } | {
+        [x: string]: any;
+        type: "percentage";
+        value: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+    } | {
+        [x: string]: any;
+        type: "boolean";
+        value: boolean;
+    }), unknown>>, z.ZodIntersection<z.ZodType<{
+        text: string;
+    } & ({
+        [x: string]: any;
+        value: number;
+        total: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+        type?: "number" | undefined;
+    } | {
+        [x: string]: any;
+        type: "percentage";
+        value: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+    } | {
+        [x: string]: any;
+        type: "boolean";
+        value: boolean;
+    }), unknown, z.core.$ZodTypeInternals<{
+        text: string;
+    } & ({
+        [x: string]: any;
+        value: number;
+        total: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+        type?: "number" | undefined;
+    } | {
+        [x: string]: any;
+        type: "percentage";
+        value: number;
+        maximumValue?: number | undefined;
+        minimumValue?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        weight?: number | undefined;
+    } | {
+        [x: string]: any;
+        type: "boolean";
+        value: boolean;
+    }), unknown>>, z.ZodObject<{
+        readOnly: z.ZodBoolean;
+        valueReference: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strip>>]>>;
     result: z.ZodType<{
         text: string;
     } & ({
@@ -54,6 +158,7 @@ export declare const criteriaTreeSchema: z.ZodObject<{
         value: boolean;
     }), unknown>>;
     certifications: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parameterHash: z.ZodOptional<z.ZodString>;
     themes: z.ZodArray<z.ZodObject<{
         code: z.ZodString;
         title: z.ZodString;

package/dist/v1/schemas/criteria-tree.js

@@ -14,8 +14,10 @@ exports.criteriaTreeSchema = data_map_1.dataMapSchema
     .pick({
     version: true,
     revision: true,
+    dataMap: true,
     result: true,
     certifications: true,
+    parameterHash: true,
 })
     .extend({
     themes: zod_1.z

package/dist/v1/schemas/data-map.d.ts

@@ -106,7 +106,7 @@ export declare const elementDataMapSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[
 export declare const dataMapSchema: z.ZodObject<{
     version: z.ZodString;
     revision: z.ZodString;
-    elements: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodType<{
+    dataMap: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodType<{
         text: string;
     } & ({
         [x: string]: any;
@@ -262,4 +262,5 @@ export declare const dataMapSchema: z.ZodObject<{
         value: boolean;
     }), unknown>>;
     certifications: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parameterHash: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/v1/schemas/data-map.js

@@ -12,12 +12,16 @@ exports.dataMapSchema = zod_1.z
         .string()
         .describe("The version of the criteria set used to generate the data map"),
     revision: zod_1.z.string().describe("The internal version of this criteria set"),
-    elements: exports.elementDataMapSchema
+    dataMap: exports.elementDataMapSchema
         .describe("The data map consisting of a map of element codes to their data"),
     result: common_1.treeResultSchema.describe("The overall result of the evaluation of the criteria set"),
     certifications: zod_1.z
         .array(zod_1.z.string())
         .optional()
         .describe("The attained certifications"),
+    parameterHash: zod_1.z
+        .string()
+        .optional()
+        .describe("The hash of the configuration. It is used to be able to compare two trees in the client side based on their configuration, as the criteria set defines which configuration options change the tree structure.")
 })
     .describe("DataMap");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openframe-org/criteria-set-protocol",
-  "version": "2.7.7",
+  "version": "2.7.8-alpha.3",
   "description": "A protocol and tools for defining and working with criteria sets",
   "private": false,
   "author": "Andrés Angulo <aa@openframe.org>",