tinybase 7.1.0-beta.2 → 7.1.0-beta.4

package/@types/schematizers/index.d.ts

@@ -39,3 +39,60 @@ export interface Schematizer {
  */
   toValuesSchema(schemas: any): ValuesSchema;
 }
+
+/**
+ * The createCustomSchematizer function creates a custom Schematizer that can
+ * convert schemas from any validation library into TinyBase schemas.
+ *
+ * This function allows you to build schematizers for validation libraries not
+ * natively supported by TinyBase. You provide two functions: one to unwrap
+ * optional/nullable/default wrappers from your library's schemas, and one to
+ * extract object properties.
+ * @param unwrapSchema - A function that unwraps a schema to extract the base
+ * type, default value, and nullable flag. It should recursively unwrap
+ * optional/nullable wrappers and return a tuple of [schema, defaultValue,
+ * allowNull].
+ * @param getProperties - A function that extracts the properties/entries/shape
+ * from an object schema. Returns undefined if the schema is not an object.
+ * @returns A new Schematizer instance.
+ * @example
+ * This example creates a custom schematizer for a hypothetical validation
+ * library.
+ *
+ * ```js
+ * import {createCustomSchematizer} from 'tinybase/schematizers';
+ *
+ * // Hypothetical library has schemas like:
+ * // {type: 'string'}, {type: 'optional', inner: ...}, etc.
+ *
+ * const unwrapSchema = (schema, defaultValue, allowNull) => {
+ *   if (schema.type === 'optional') {
+ *     return unwrapSchema(schema.inner, defaultValue, allowNull);
+ *   }
+ *   if (schema.type === 'nullable') {
+ *     return unwrapSchema(schema.inner, defaultValue, true);
+ *   }
+ *   return [schema, defaultValue ?? schema.default, allowNull ?? false];
+ * };
+ *
+ * const getProperties = (schema) => schema.fields;
+ *
+ * const schematizer = createCustomSchematizer(unwrapSchema, getProperties);
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: {type: 'object', fields: {name: {type: 'string'}}},
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {name: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createCustomSchematizer(
+  unwrapSchema: (
+    schema: any,
+    defaultValue?: any,
+    allowNull?: boolean,
+  ) => [any, any, boolean],
+  getProperties: (schema: any) => any | undefined,
+): Schematizer;

package/@types/schematizers/schematizer-arktype/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The schematizer-arktype module provides conversion utilities for ArkType
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-arktype
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The ArkTypeSchematizer interface represents a schematizer specifically for
+ * converting ArkType schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface ArkTypeSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of ArkType object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from ArkType schemas. Complex validation
+ * rules like min/max, regex patterns, refinements, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to ArkType object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts ArkType schemas to TinyBase format.
+ *
+ * ```js
+ * import {type} from 'arktype';
+ * import {createStore} from 'tinybase';
+ * import {createArkTypeSchematizer} from 'tinybase/schematizers/schematizer-arktype';
+ *
+ * const schematizer = createArkTypeSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: type({
+ *     species: 'string',
+ *     age: 'number',
+ *     sold: type('boolean').default(false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of ArkType schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information and default values from ArkType
+ * schemas.
+ * @param schemas - A mapping of value IDs to ArkType schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts ArkType value schemas.
+ *
+ * ```js
+ * import {type} from 'arktype';
+ * import {createStore} from 'tinybase';
+ * import {createArkTypeSchematizer} from 'tinybase/schematizers/schematizer-arktype';
+ *
+ * const schematizer = createArkTypeSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: type('string').default('light'),
+ *   count: 'number',
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * console.log(store.getValues());
+ * // -> {theme: 'light'}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createArkTypeSchematizer function creates an ArkTypeSchematizer object
+ * that can convert ArkType schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new ArkTypeSchematizer instance.
+ * @example
+ * This example creates an ArkType schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {type} from 'arktype';
+ * import {createArkTypeSchematizer} from 'tinybase/schematizers/schematizer-arktype';
+ *
+ * const schematizer = createArkTypeSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: type({
+ *     species: 'string',
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createArkTypeSchematizer(): ArkTypeSchematizer;

package/@types/schematizers/schematizer-arktype/with-schemas/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The schematizer-arktype module provides conversion utilities for ArkType
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-arktype
+ * @since v7.1.0
+ */
+export type {ArkTypeSchematizer} from '../index.d.ts';

package/@types/schematizers/schematizer-effect/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The schematizer-effect module provides conversion utilities for Effect
+ * Schema schemas.
+ * @packageDocumentation
+ * @module schematizer-effect
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The EffectSchematizer interface represents a schematizer specifically for
+ * converting Effect Schema schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface EffectSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Effect Schema struct schemas
+ * into a TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * nullable flags, and optional flags from Effect schemas. Default values are
+ * not supported as they exist in Effect's runtime transformations, not in the
+ * schema AST. Complex validation rules, transformations, and refinements are
+ * ignored.
+ * @param schemas - A mapping of table IDs to Effect Schema struct schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Effect Schema schemas to TinyBase format.
+ *
+ * ```js
+ * import {Boolean, Number, String, Struct} from 'effect/Schema';
+ * import {createStore} from 'tinybase';
+ * import {createEffectSchematizer} from 'tinybase/schematizers/schematizer-effect';
+ *
+ * const schematizer = createEffectSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Struct({
+ *     species: String,
+ *     age: Number,
+ *     sold: Boolean,
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3, sold: false});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Effect Schema schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * nullable flags, and optional flags from Effect schemas. Default values are
+ * not supported as they exist in Effect's runtime transformations, not in the
+ * schema AST.
+ * @param schemas - A mapping of value IDs to Effect Schema schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Effect Schema schemas to TinyBase values.
+ *
+ * ```js
+ * import {Boolean, Number} from 'effect/Schema';
+ * import {createStore} from 'tinybase';
+ * import {createEffectSchematizer} from 'tinybase/schematizers/schematizer-effect';
+ *
+ * const schematizer = createEffectSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   open: Boolean,
+ *   employees: Number,
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * store.setValues({open: true, employees: 3});
+ * console.log(store.getValues());
+ * // -> {open: true, employees: 3}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createEffectSchematizer function creates an EffectSchematizer instance
+ * for converting Effect Schema schemas to TinyBase schemas.
+ * @returns A new EffectSchematizer instance.
+ * @example
+ * This example creates an Effect Schema schematizer.
+ *
+ * ```js
+ * import {String, Struct} from 'effect/Schema';
+ * import {createEffectSchematizer} from 'tinybase/schematizers/schematizer-effect';
+ *
+ * const schematizer = createEffectSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Struct({
+ *     species: String,
+ *   }),
+ * });
+ *
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createEffectSchematizer(): EffectSchematizer;

package/@types/schematizers/schematizer-effect/with-schemas/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The schematizer-effect module provides conversion utilities for Effect
+ * Schema schemas.
+ * @packageDocumentation
+ * @module schematizer-effect
+ * @since v7.1.0
+ */
+export type {EffectSchematizer, createEffectSchematizer} from '../index.d.ts';

package/@types/schematizers/schematizer-valibot/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The schematizer-valibot module provides conversion utilities for Valibot
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-valibot
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The ValibotSchematizer interface represents a schematizer specifically for
+ * converting Valibot schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface ValibotSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Valibot object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * fallback values, and nullable flags from Valibot schemas. Complex validation
+ * rules like min/max, regex patterns, refinements, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to Valibot object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Valibot schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {boolean, fallback, number, object, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *     age: number(),
+ *     sold: fallback(boolean(), false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Valibot schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information and fallback values from Valibot
+ * schemas.
+ * @param schemas - A mapping of value IDs to Valibot schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Valibot value schemas.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {fallback, number, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: fallback(string(), 'light'),
+ *   count: number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * console.log(store.getValues());
+ * // -> {theme: 'light'}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createValibotSchematizer function creates a ValibotSchematizer object
+ * that can convert Valibot schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new ValibotSchematizer instance.
+ * @example
+ * This example creates a Valibot schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {createValibotSchematizer} from 'tinybase/schematizers/schematizer-valibot';
+ * import {object, string} from 'valibot';
+ *
+ * const schematizer = createValibotSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createValibotSchematizer(): ValibotSchematizer;

package/@types/schematizers/schematizer-valibot/with-schemas/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The schematizer-valibot module provides conversion utilities for Valibot
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-valibot
+ * @since v7.1.0
+ */
+export type {ValibotSchematizer} from '../index.d.ts';

package/@types/schematizers/schematizer-yup/index.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The schematizer-yup module provides conversion utilities for Yup schemas.
+ * @packageDocumentation
+ * @module schematizer-yup
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The YupSchematizer interface represents a schematizer specifically for
+ * converting Yup schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface YupSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Yup object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from Yup schemas. Complex validation
+ * rules like min/max, regex patterns, tests, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to Yup object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Yup schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {boolean, number, object, string} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *     age: number(),
+ *     sold: boolean().default(false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Yup schemas into a TinyBase
+ * ValuesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from Yup schemas.
+ * @param schemas - A mapping of value IDs to Yup schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Yup schemas to TinyBase values.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {boolean, number} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   open: boolean().default(true),
+ *   employees: number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * console.log(store.getValues());
+ * // -> {open: true}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createYupSchematizer function creates a YupSchematizer instance for
+ * converting Yup schemas to TinyBase schemas.
+ * @returns A new YupSchematizer instance.
+ * @example
+ * This example creates a Yup schematizer.
+ *
+ * ```js
+ * import {createYupSchematizer} from 'tinybase/schematizers/schematizer-yup';
+ * import {object, string} from 'yup';
+ *
+ * const schematizer = createYupSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: object({
+ *     species: string(),
+ *   }),
+ * });
+ *
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createYupSchematizer(): YupSchematizer;

package/@types/schematizers/schematizer-yup/with-schemas/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The schematizer-yup module provides conversion utilities for Yup schemas.
+ * @packageDocumentation
+ * @module schematizer-yup
+ * @since v7.1.0
+ */
+export type {YupSchematizer, createYupSchematizer} from '../index.d.ts';

package/checkpoints/index.js

@@ -44,7 +44,7 @@ const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
-  value === void 0 ? (collDel(map, key), map) : map?.set(key, value);
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
@@ -114,7 +114,7 @@ const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const deep = (node, p) =>
     p == size(path)
       ? arrayPush(leaves, node)
-      : path[p] === null
+      : isNull(path[p])
         ? collForEach(node, (node2) => deep(node2, p + 1))
         : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);

package/checkpoints/with-schemas/index.js

@@ -44,7 +44,7 @@ const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
-  value === void 0 ? (collDel(map, key), map) : map?.set(key, value);
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
@@ -114,7 +114,7 @@ const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const deep = (node, p) =>
     p == size(path)
       ? arrayPush(leaves, node)
-      : path[p] === null
+      : isNull(path[p])
         ? collForEach(node, (node2) => deep(node2, p + 1))
         : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);

package/index.js

@@ -51,6 +51,8 @@ const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isNullish = (thing) => thing == null;
 const isUndefined = (thing) => thing === void 0;
 const isNull = (thing) => thing === null;
+const isTrue = (thing) => thing === true;
+const isFalse = (thing) => thing === false;
 const ifNotNullish = getIfNotFunction(isNullish);
 const ifNotUndefined = getIfNotFunction(isUndefined);
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
@@ -188,7 +190,7 @@ const mapForEach = (map, cb) =>
 const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
-  value === void 0 ? (collDel(map, key), map) : map?.set(key, value);
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
@@ -456,7 +458,7 @@ const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const deep = (node, p) =>
     p == size(path)
       ? arrayPush(leaves, node)
-      : path[p] === null
+      : isNull(path[p])
         ? collForEach(node, (node2) => deep(node2, p + 1))
         : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);
@@ -3133,8 +3135,8 @@ const createMetrics = getCreateFunction((store) => {
     (value) =>
       isNaN(value) ||
       isUndefined(value) ||
-      value === true ||
-      value === false ||
+      isTrue(value) ||
+      isFalse(value) ||
       value === EMPTY_STRING
         ? void 0
         : value * 1,

package/indexes/index.js

@@ -51,7 +51,7 @@ const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
-  value === void 0 ? (collDel(map, key), map) : map?.set(key, value);
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
@@ -283,7 +283,7 @@ const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const deep = (node, p) =>
     p == size(path)
       ? arrayPush(leaves, node)
-      : path[p] === null
+      : isNull(path[p])
         ? collForEach(node, (node2) => deep(node2, p + 1))
         : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);

package/indexes/with-schemas/index.js

@@ -51,7 +51,7 @@ const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
   collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
-  value === void 0 ? (collDel(map, key), map) : map?.set(key, value);
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
@@ -283,7 +283,7 @@ const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const deep = (node, p) =>
     p == size(path)
       ? arrayPush(leaves, node)
-      : path[p] === null
+      : isNull(path[p])
         ? collForEach(node, (node2) => deep(node2, p + 1))
         : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
   deep(deepIdSet, 0);