@calcit/procs 0.29.0-alpha.17 → 0.29.0-alpha.19

package/lib/calcit.procs.d.mts

@@ -112,7 +112,7 @@ export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _$n__$M_: (...xs: CalcitValue[]) => CalcitSliceMap;
 export declare let defatom: (path: string, x: CalcitValue) => CalcitValue;
-export { atom } from "./js-ref.mjs";
+export { atom, ref } from "./js-ref.mjs";
 export declare let peekDefatom: (path: string) => CalcitRef;
 export declare let _$n_atom_$o_deref: (x: CalcitRef) => CalcitValue;
 export declare let _$n__ADD_: (x: number, y: number) => number;

package/lib/calcit.procs.mjs

@@ -508,7 +508,7 @@ export let defatom = (path, x) => {
     refsRegistry.set(path, v);
     return v;
 };
-export { atom } from "./js-ref.mjs";
+export { atom, ref } from "./js-ref.mjs";
 export let peekDefatom = (path) => {
     return refsRegistry.get(path);
 };

package/lib/js-ref.d.mts

@@ -9,4 +9,7 @@ export declare class CalcitRef {
     constructor(x: CalcitValue, path: string);
     toString(): string;
 }
+/** Creates a local `Ref<T>`; generated code calls this for both `ref` and the compatibility spelling `atom`. */
+export declare let ref: (x: CalcitValue) => CalcitValue;
+/** Compatibility export for JavaScript callers written before `ref`; it is the same function. */
 export declare let atom: (x: CalcitValue) => CalcitValue;

package/lib/js-ref.mjs

@@ -10,8 +10,11 @@ export class CalcitRef {
     }
 }
 var atomCounter = 0;
-export let atom = (x) => {
+/** Creates a local `Ref<T>`; generated code calls this for both `ref` and the compatibility spelling `atom`. */
+export let ref = (x) => {
     atomCounter = atomCounter + 1;
     let v = new CalcitRef(x, `atom-${atomCounter}`);
     return v;
 };
+/** Compatibility export for JavaScript callers written before `ref`; it is the same function. */
+export let atom = ref;

package/lib/js-struct-def.d.mts

@@ -12,5 +12,5 @@ export declare class CalcitStructDef {
     withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStructDef;
     toString(disableJsDataWarning?: boolean): string;
 }
-/** Match native definition binding without replacing an alias's existing identity. */
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
 export declare function bind_struct_definition(value: CalcitValue, definitionRef: string): CalcitValue;

package/lib/js-struct-def.mjs

@@ -1,5 +1,7 @@
 import { canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
 export class CalcitStructDef {
     constructor(name, fields, fieldTypes, impls = [], definitionRef = null) {
         const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
@@ -33,10 +35,15 @@ export class CalcitStructDef {
         return parts.join("");
     }
 }
-/** Match native definition binding without replacing an alias's existing identity. */
+/** Bind nominal definitions like native, preserving an alias's existing identity. */
 export function bind_struct_definition(value, definitionRef) {
     if (value instanceof CalcitStructDef && value.definitionRef == null) {
         return new CalcitStructDef(value.name, value.fields, value.fieldTypes, value.impls, definitionRef);
     }
+    if (value instanceof CalcitEnumDef && value.prototype.structRef.definitionRef == null) {
+        const prototype = value.prototype;
+        const structRef = bind_struct_definition(prototype.structRef, definitionRef);
+        return new CalcitEnumDef(new CalcitStructValue(prototype.name, prototype.fields, prototype.values, structRef));
+    }
     return value;
 }

package/lib/js-struct-value.mjs

@@ -2,6 +2,14 @@ import { CalcitImpl } from "./js-impl.mjs";
 import { newTag, castTag, toString, getStringName, findInFields, compareTagNames, canonicalizeTagPairs, } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitStructDef } from "./js-struct-def.mjs";
+import { valueMatchesTypeForm } from "./js-type-form.mjs";
+/// Field writes check the declared field type, like the native runtime.
+let assertFieldValue = (structRef, idx, value, operation) => {
+    const fieldType = structRef?.fieldTypes?.[idx];
+    if (fieldType != null && !valueMatchesTypeForm(value, fieldType)) {
+        throw new Error(`${operation} field :${structRef.fields[idx].value} expects type ${toString(fieldType, true)}, but received ${toString(value, true)}`);
+    }
+};
 export class CalcitStructValue {
     constructor(name, fields, values, structRef) {
         this.name = name;
@@ -44,6 +52,7 @@ export class CalcitStructValue {
         let k_id = castTag(k);
         for (let idx = 0; idx < this.fields.length; idx++) {
             if (this.fields[idx] === k_id) {
+                assertFieldValue(this.structRef, idx, v, "&struct:assoc");
                 values[idx] = v;
             }
             else {
@@ -60,6 +69,7 @@ export class CalcitStructValue {
     assocAt(index, field, value) {
         const idx = checkedStructIndex(index, "&struct:assoc-at");
         this.assertFieldAt(idx, field, "&struct:assoc-at");
+        assertFieldValue(this.structRef, idx, value, "&struct:assoc-at");
         const values = this.values.slice();
         values[idx] = value;
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
@@ -72,6 +82,7 @@ export class CalcitStructValue {
         for (let base = 0; base < triples.length; base += 3) {
             const idx = checkedStructIndex(triples[base], "&struct:with-at");
             this.assertFieldAt(idx, triples[base + 1], "&struct:with-at");
+            assertFieldValue(this.structRef, idx, triples[base + 2], "&struct:with-at");
             values[idx] = triples[base + 2];
         }
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
@@ -234,6 +245,7 @@ export let _$n_struct_$o_with = (proto, ...xs) => {
             if (idx < 0) {
                 throw new Error(`Cannot find field ${k} among ${proto.fields}`);
             }
+            assertFieldValue(proto.structRef, idx, v, "&struct:with");
             values[idx] = v;
         }
         return new CalcitStructValue(proto.name, proto.fields, values, proto.structRef);

package/lib/js-type-form.d.mts

@@ -0,0 +1,2 @@
+import { CalcitValue } from "./js-primes.mjs";
+export declare let valueMatchesTypeForm: (value: CalcitValue, form: CalcitValue) => boolean;

package/lib/js-type-form.mjs

@@ -0,0 +1,167 @@
+import { CalcitSymbol, CalcitTag } from "./calcit-data.mjs";
+import { CalcitList, CalcitSliceList } from "./js-list.mjs";
+import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitSet } from "./js-set.mjs";
+import { CalcitRef } from "./js-ref.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
+/// Shallow runtime check of a value against a struct field type form, matching
+/// the native `value_matches_type_annotation`: container kinds are checked,
+/// members are not. Names that cannot be resolved here (aliases, traits, type
+/// variables) stay permissive, as unresolved forms are on the native side.
+export let valueMatchesTypeForm = (value, form) => {
+    if (form instanceof CalcitSliceList || form instanceof CalcitList) {
+        const items = form.toArray();
+        const head = items[0];
+        if (head instanceof CalcitSymbol && head.value === "quote") {
+            return valueMatchesTypeForm(value, items[1]);
+        }
+        if (head instanceof CalcitSymbol && head.value === "::") {
+            const name = typeFormName(items[1]);
+            // Nil is `null` here; `undefined` is Unit. Only the JS host boundary
+            // type also admits `undefined`.
+            if (name === "Optional") {
+                return value === null || valueMatchesTypeForm(value, items[2]);
+            }
+            if (name === "JsNullish") {
+                return value == null || valueMatchesTypeForm(value, items[2]);
+            }
+            return name == null || valueMatchesTypeName(value, name);
+        }
+        return true;
+    }
+    const name = typeFormName(form);
+    return name == null || valueMatchesTypeName(value, name);
+};
+let typeFormName = (form) => {
+    if (form instanceof CalcitSymbol)
+        return form.value;
+    if (form instanceof CalcitTag)
+        return form.value;
+    if (form instanceof CalcitSliceList || form instanceof CalcitList) {
+        const items = form.toArray();
+        if (items[0] instanceof CalcitSymbol && items[0].value === "quote")
+            return typeFormName(items[1]);
+    }
+    return null;
+};
+/// Numeric refinements check range and integrality like the native `CalcitNumericRefinement::accepts`.
+let isIntegerIn = (value, min, max) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+let isList = (value) => value instanceof CalcitList || value instanceof CalcitSliceList;
+let isMap = (value) => value instanceof CalcitMap || value instanceof CalcitSliceMap;
+let valueMatchesTypeName = (value, rawName) => {
+    const name = rawName.startsWith("calcit.core/") ? rawName.slice("calcit.core/".length) : rawName;
+    switch (name) {
+        case "Dynamic":
+        case "dynamic":
+        case "any":
+        case "JsObject":
+            return true;
+        case "Number":
+        case "number":
+        case "Float64":
+        case "float64":
+            return typeof value === "number";
+        case "Float32":
+        case "float32":
+            return typeof value === "number" && Math.fround(value) === value;
+        case "Int8":
+        case "int8":
+            return isIntegerIn(value, -128, 127);
+        case "UInt8":
+        case "uint8":
+            return isIntegerIn(value, 0, 255);
+        case "Int16":
+        case "int16":
+            return isIntegerIn(value, -32768, 32767);
+        case "UInt16":
+        case "uint16":
+            return isIntegerIn(value, 0, 65535);
+        case "Int32":
+        case "int32":
+            return isIntegerIn(value, -2147483648, 2147483647);
+        case "UInt32":
+        case "uint32":
+            return isIntegerIn(value, 0, 4294967295);
+        case "Int64":
+        case "int64":
+            return isIntegerIn(value, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        case "UInt64":
+        case "uint64":
+            return isIntegerIn(value, 0, Number.MAX_SAFE_INTEGER);
+        case "String":
+        case "string":
+            return typeof value === "string";
+        case "Bool":
+        case "bool":
+            return typeof value === "boolean";
+        case "Tag":
+        case "tag":
+            return value instanceof CalcitTag;
+        case "Symbol":
+        case "symbol":
+            return value instanceof CalcitSymbol;
+        case "Nil":
+        case "nil":
+            return value === null;
+        case "Unit":
+        case "unit":
+            return value === undefined;
+        case "List":
+        case "list":
+            return isList(value);
+        case "Map":
+        case "map":
+            return isMap(value);
+        case "Set":
+        case "set":
+            return value instanceof CalcitSet;
+        case "Ref":
+        case "ref":
+            return value instanceof CalcitRef;
+        case "Fn":
+        case "fn":
+            return typeof value === "function";
+        case "Struct":
+        case "struct":
+        case "record":
+            return isStructValue(value);
+        case "Enum":
+        case "enum":
+        case "tuple":
+            return value instanceof CalcitEnumValue;
+    }
+    // Core Struct and Enum definitions (bare names resolve to them through the
+    // implicit core import) are known here, so a reference to one admits only
+    // values of that definition, as the native matcher does.
+    if (CORE_NOMINAL_DEFS.has(name)) {
+        if (isStructValue(value))
+            return value.structRef.definitionRef === `calcit.core/${name}`;
+        return value instanceof CalcitEnumValue && value.enumPrototype?.prototype.structRef.definitionRef === `calcit.core/${name}`;
+    }
+    // Other names may be type variables, aliases or traits that cannot be
+    // resolved here. A qualified reference is checked against the value's own
+    // Struct or Enum name; other values are left to the static checker like
+    // unresolved forms.
+    const shortName = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+    if (isStructValue(value))
+        return value.name.value === shortName || !name.includes("/");
+    if (value instanceof CalcitEnumValue && value.enumPrototype != null) {
+        return value.enumPrototype.name() === shortName || !name.includes("/");
+    }
+    return true;
+};
+/// Struct and Enum definitions of `calcit.core` usable as field types.
+const CORE_NOMINAL_DEFS = new Set([
+    "Option",
+    "Result",
+    "Data",
+    "ListDestruct",
+    "MapDestruct",
+    "SetDestruct",
+    "StringDestruct",
+    "MapEntry",
+    "RuntimeMapMeta",
+    "RuntimeMapResponse",
+]);
+// Duck-typed to avoid a module cycle with js-struct-value.
+let isStructValue = (value) => value != null && typeof value === "object" && "structRef" in value && "fields" in value;

package/lib/package.json

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

package/package.json

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