npm - @calcit/procs - Versions diffs - 0.29.0-alpha.28 → 0.29.0-alpha.29 - Mend

@calcit/procs 0.29.0-alpha.28 → 0.29.0-alpha.29

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/lib/calcit.procs.d.mts CHANGED Viewed

@@ -398,7 +398,7 @@ export declare let macroexpand_all: () => void;
 export declare let _$n_get_calcit_running_mode: () => void;
 export declare let _$n_get_def_doc: () => void;
 export declare let _$n_get_def_schema: () => void;
-export declare let _$n_ffi_response_resolve: () => void;
-export declare let _$n_ffi_response_reject: () => void;
-export declare let _$n_ffi_task_cancel: () => void;
+export declare let _$n_ffi_response_resolve: (..._args: CalcitValue[]) => never;
+export declare let _$n_ffi_response_reject: (..._args: CalcitValue[]) => never;
+export declare let _$n_ffi_task_cancel: (..._args: CalcitValue[]) => never;
 export declare let raise: () => void;

package/lib/calcit.procs.mjs CHANGED Viewed

@@ -2039,75 +2039,75 @@ const typed_edn_error = (path, message) => {
 const enum_prototype_name = (value) => {
     return value instanceof CalcitEnumDef ? value.name() : value.name.value;
 };
-const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
+const decode_typed_edn_node = (graph, nodeId, input, path, depth, fail = typed_edn_error) => {
     if (depth > 1024)
-        typed_edn_error(path, "decode nesting exceeds 1024");
+        fail(path, "decode nesting exceeds 1024");
     const node = graph.nodes[nodeId];
     if (node == null)
-        typed_edn_error(path, `invalid data shape node #${nodeId}`);
+        fail(path, `invalid data shape node #${nodeId}`);
     switch (node.kind) {
         case "nil":
             if (input === null)
                 return null;
-            return typed_edn_error(path, `expected Nil, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected nil, got ${typed_edn_kind(input)}`);
         case "unit":
             if (input === undefined)
                 return input;
-            return typed_edn_error(path, `expected Unit, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected &unit, got ${typed_edn_kind(input)}`);
         case "bool":
             if (typeof input === "boolean")
                 return input;
-            return typed_edn_error(path, `expected bool, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected bool, got ${typed_edn_kind(input)}`);
         case "number":
             if (typeof input === "number")
                 return input;
-            return typed_edn_error(path, `expected number, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected number, got ${typed_edn_kind(input)}`);
         case "numeric":
             if (typeof input !== "number")
-                return typed_edn_error(path, `expected ${node.target}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected ${node.target}, got ${typed_edn_kind(input)}`);
             if (_$n_number_$o_fits_$q_(input, newTag(node.target)))
                 return input;
-            return typed_edn_error(path, `number ${input} does not fit ${node.target}`);
+            return fail(path, `number ${input} does not fit ${node.target}`);
         case "string":
             if (typeof input === "string")
                 return input;
-            return typed_edn_error(path, `expected string, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected string, got ${typed_edn_kind(input)}`);
         case "symbol":
             if (input instanceof CalcitSymbol)
                 return input;
-            return typed_edn_error(path, `expected symbol, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected symbol, got ${typed_edn_kind(input)}`);
         case "tag":
             if (input instanceof CalcitTag)
                 return input;
-            return typed_edn_error(path, `expected tag, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected tag, got ${typed_edn_kind(input)}`);
         case "buffer":
             if (input instanceof Uint8Array)
                 return input;
-            return typed_edn_error(path, `expected buffer, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected buffer, got ${typed_edn_kind(input)}`);
         case "cirru-quote":
             if (input instanceof CalcitCirruQuote)
                 return input;
-            return typed_edn_error(path, `expected cirru-quote, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected cirru-quote, got ${typed_edn_kind(input)}`);
         case "optional":
-            return input === null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1);
+            return input === null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1, fail);
         case "list": {
             if (!(input instanceof CalcitList || input instanceof CalcitSliceList)) {
-                return typed_edn_error(path, `expected list, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected list, got ${typed_edn_kind(input)}`);
             }
-            const values = Array.from(input.items()).map((value, idx) => decode_typed_edn_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1));
+            const values = Array.from(input.items()).map((value, idx) => decode_typed_edn_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1, fail));
             return new CalcitSliceList(values);
         }
         case "set": {
             if (!(input instanceof CalcitSet || input instanceof TypedEdnSetView)) {
-                return typed_edn_error(path, `expected set, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected set, got ${typed_edn_kind(input)}`);
             }
             const values = [];
             const inputValues = input instanceof TypedEdnSetView ? input.items : input.values();
             inputValues.forEach((value) => {
                 const itemPath = `${path}.item`;
-                const decoded = decode_typed_edn_node(graph, node.inner, value, itemPath, depth + 1);
+                const decoded = decode_typed_edn_node(graph, node.inner, value, itemPath, depth + 1, fail);
                 if (values.some((existing) => _$n__$e_(existing, decoded))) {
-                    typed_edn_error(itemPath, "duplicate decoded set value");
+                    fail(itemPath, "duplicate decoded set value");
                 }
                 values.push(decoded);
             });
@@ -2115,53 +2115,53 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
         }
         case "map": {
             if (!(input instanceof CalcitMap || input instanceof CalcitSliceMap)) {
-                return typed_edn_error(path, `expected map, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected map, got ${typed_edn_kind(input)}`);
             }
             const entries = [];
             input.pairs().forEach(([key, value]) => {
                 const keyPath = `${path}.key`;
-                const decodedKey = decode_typed_edn_node(graph, node.key, key, keyPath, depth + 1);
+                const decodedKey = decode_typed_edn_node(graph, node.key, key, keyPath, depth + 1, fail);
                 for (let idx = 0; idx < entries.length; idx += 2) {
                     if (_$n__$e_(entries[idx], decodedKey)) {
-                        typed_edn_error(keyPath, "duplicate decoded map key");
+                        fail(keyPath, "duplicate decoded map key");
                     }
                 }
-                const decodedValue = decode_typed_edn_node(graph, node.value, value, `${path}.value`, depth + 1);
+                const decodedValue = decode_typed_edn_node(graph, node.value, value, `${path}.value`, depth + 1, fail);
                 entries.push(decodedKey, decodedValue);
             });
             return new CalcitSliceMap(entries);
         }
         case "ref":
             if (!(input instanceof CalcitRef))
-                return typed_edn_error(path, `expected atom, got ${typed_edn_kind(input)}`);
-            return atom(decode_typed_edn_node(graph, node.inner, input.value, `${path}.value`, depth + 1));
+                return fail(path, `expected atom, got ${typed_edn_kind(input)}`);
+            return atom(decode_typed_edn_node(graph, node.inner, input.value, `${path}.value`, depth + 1, fail));
         case "struct": {
             if (!(input instanceof CalcitStructValue)) {
-                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
             }
             if (input.name.value !== node.nominal.name.value) {
-                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got struct :${input.name.value}`);
+                return fail(path, `expected struct :${node.nominal.name.value}, got struct :${input.name.value}`);
             }
             const expectedNames = node.fields.map(([name]) => name);
             const actualNames = input.fields.map((field) => field.value);
             const missing = expectedNames.filter((name) => !actualNames.includes(name)).sort();
             const unknown = actualNames.filter((name) => !expectedNames.includes(name)).sort();
             if (missing.length > 0 || unknown.length > 0 || expectedNames.length !== actualNames.length) {
-                return typed_edn_error(path, `struct :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
+                return fail(path, `struct :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
             }
             const decodedFields = new Map();
             node.fields.forEach(([name, fieldNode]) => {
                 const idx = actualNames.indexOf(name);
-                decodedFields.set(name, decode_typed_edn_node(graph, fieldNode, input.values[idx], `${path}.${name}`, depth + 1));
+                decodedFields.set(name, decode_typed_edn_node(graph, fieldNode, input.values[idx], `${path}.${name}`, depth + 1, fail));
             });
             // Re-align by name so values produced by older runtimes or external data
             // still adopt the current nominal declaration's canonical field layout.
             if (decodedFields.size !== node.nominal.fields.length) {
-                return typed_edn_error(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
+                return fail(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
             }
             const values = node.nominal.fields.map((field) => {
                 if (!decodedFields.has(field.value)) {
-                    return typed_edn_error(path, `struct :${node.nominal.name.value} is missing declared field :${field.value}`);
+                    return fail(path, `struct :${node.nominal.name.value} is missing declared field :${field.value}`);
                 }
                 return decodedFields.get(field.value);
             });
@@ -2169,28 +2169,28 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
         }
         case "enum": {
             if (!(input instanceof CalcitEnumValue) || input.enumPrototype == null) {
-                return typed_edn_error(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
             }
             const actualEnumName = enum_prototype_name(input.enumPrototype);
             if (actualEnumName !== node.nominal.name()) {
-                return typed_edn_error(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
+                return fail(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
             }
             if (!(input.tag instanceof CalcitTag)) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} variant must be a tag`);
+                return fail(path, `enum :${node.nominal.name()} variant must be a tag`);
             }
             const inputTag = input.tag;
             const variant = node.variants.find((candidate) => candidate.tag === inputTag.value);
             if (variant == null) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
+                return fail(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
             }
             if (variant.payload.length !== input.extra.length) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} variant :${variant.tag} expects ${variant.payload.length} payload(s), got ${input.extra.length}`);
+                return fail(path, `enum :${node.nominal.name()} variant :${variant.tag} expects ${variant.payload.length} payload(s), got ${input.extra.length}`);
             }
-            const values = variant.payload.map((payloadNode, idx) => decode_typed_edn_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1));
+            const values = variant.payload.map((payloadNode, idx) => decode_typed_edn_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1, fail));
             return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
         }
         default:
-            return typed_edn_error(path, `invalid data shape node kind: ${node.kind}`);
+            return fail(path, `invalid data shape node kind: ${node.kind}`);
     }
 };
 export let parse_cirru_edn_as = (code, graph) => {
@@ -2341,7 +2341,7 @@ const decode_runtime_map_node = (graph, nodeId, input, path, depth) => {
             return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
         }
         default:
-            return decode_typed_edn_node(graph, nodeId, input, path, depth);
+            return decode_typed_edn_node(graph, nodeId, input, path, depth, map_decode_error);
     }
 };
 export let decode_map_as = (value, graph) => {
@@ -3102,8 +3102,12 @@ export let macroexpand_all = unavailableProc;
 export let _$n_get_calcit_running_mode = unavailableProc;
 export let _$n_get_def_doc = unavailableProc;
 export let _$n_get_def_schema = unavailableProc;
-export let _$n_ffi_response_resolve = unavailableProc;
-export let _$n_ffi_response_reject = unavailableProc;
-export let _$n_ffi_task_cancel = unavailableProc;
+// A missing native lifecycle capability must not look like a successful Unit.
+const unavailableNativeFfi = (operation) => {
+    throw new Error(`${operation}: native FFI capability is not available for calcit-js`);
+};
+export let _$n_ffi_response_resolve = (..._args) => unavailableNativeFfi("&ffi-response-resolve");
+export let _$n_ffi_response_reject = (..._args) => unavailableNativeFfi("&ffi-response-reject");
+export let _$n_ffi_task_cancel = (..._args) => unavailableNativeFfi("&ffi-task-cancel");
 // already handled in code emitter
 export let raise = unavailableProc;

package/lib/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.28",
+    "version": "0.29.0-alpha.29",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.28",
+  "version": "0.29.0-alpha.29",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",