@agiledigital/pingone-aic-script-tester 0.1.0

package/dist/src/schema.js

@@ -0,0 +1,93 @@
+/** Contexts-endpoint binding metadata (`docs/api/bindings/*.json`). */
+export const JS_TYPES = [
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "array",
+    "unknown",
+    "void",
+];
+export function classifyBinding(binding) {
+    if (binding.javaScriptType === "string" ||
+        binding.javaScriptType === "number" ||
+        binding.javaScriptType === "boolean") {
+        if (binding.elements.length > 0) {
+            throw new Error(`rhino-local: scalar binding "${binding.name}" unexpectedly has elements`);
+        }
+        return "scalar";
+    }
+    if (binding.elements.length === 0) {
+        return "opaque";
+    }
+    return "object";
+}
+/** Group overloads of the same name; preserve first-seen member order. */
+export function membersOf(elements) {
+    const order = [];
+    const methods = new Map();
+    const fields = new Map();
+    for (const element of elements) {
+        if (element.elementType === "method") {
+            if (fields.has(element.name)) {
+                throw new Error(`rhino-local: "${element.name}" is both a method and a field`);
+            }
+            let overloads = methods.get(element.name);
+            if (!overloads) {
+                order.push(element.name);
+                overloads = [];
+                methods.set(element.name, overloads);
+            }
+            overloads.push(element);
+            continue;
+        }
+        if (methods.has(element.name)) {
+            throw new Error(`rhino-local: "${element.name}" is both a method and a field`);
+        }
+        if (!fields.has(element.name)) {
+            order.push(element.name);
+        }
+        fields.set(element.name, element);
+    }
+    return order.map((name) => {
+        const overloads = methods.get(name);
+        if (overloads) {
+            return { kind: "method", name, overloads: uniqueOverloads(overloads) };
+        }
+        const field = fields.get(name);
+        if (!field) {
+            throw new Error(`rhino-local: missing grouped member "${name}"`);
+        }
+        return {
+            kind: "field",
+            name,
+            javaScriptType: field.javaScriptType,
+            elements: field.elements,
+        };
+    });
+}
+export function uniqueOverloads(overloads) {
+    const seen = new Set();
+    const unique = [];
+    for (const overload of overloads) {
+        // Collapse identical JSON copies (callbacksBuilder.confirmationCallback
+        // repeats the same signature) but keep overloads that differ only by
+        // parameter name (logger.info(format, arg) vs info(msg, t)).
+        const key = `${overloadLabel(overload)}:${overload.returnType}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(overload);
+    }
+    return unique;
+}
+export function overloadKey(overload) {
+    return `${overload.parameters.map((parameter) => parameter.javaScriptType).join(",")}->${overload.returnType}`;
+}
+export function overloadLabel(overload) {
+    const params = overload.parameters
+        .map((parameter) => `${parameter.name}: ${parameter.javaScriptType}`)
+        .join(", ");
+    return `${overload.name}(${params})`;
+}