tinybase 7.1.0-beta.0 → 7.1.0-beta.2

package/schematizers/index.js

@@ -0,0 +1 @@
+

package/schematizers/schematizer-typebox/index.js

@@ -0,0 +1,106 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
+
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value) ? otherwise?.() : then(value);
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const size = (arrayOrString) => arrayOrString.length;
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objForEach = (obj, cb) =>
+  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const ANY_OF = 'anyOf';
+const unwrapSchema = (schema, defaultValue, allowNull) => {
+  if (schema?.[ANY_OF]) {
+    const types = schema[ANY_OF];
+    const hasNull = types.some((t) => t?.type === NULL);
+    const nonNullType = types.find((t) => t?.type !== NULL);
+    if (hasNull && nonNullType) {
+      return unwrapSchema(nonNullType, defaultValue ?? schema?.[DEFAULT], true);
+    }
+  }
+  return [schema, defaultValue ?? schema?.[DEFAULT], allowNull ?? false];
+};
+const createTypeBoxSchematizer = () => {
+  const toTablesSchema = (schemas) => {
+    const tablesSchema = objNew();
+    objForEach(schemas, (typeBoxSchema, tableId) => {
+      const tableSchema = objNew();
+      ifNotUndefined(typeBoxSchema?.properties, (properties) =>
+        objForEach(properties, (cellTypeBoxSchema, cellId) =>
+          ifNotUndefined(
+            toCellOrValueSchema(cellTypeBoxSchema),
+            (cellSchema) => {
+              tableSchema[cellId] = cellSchema;
+            },
+          ),
+        ),
+      );
+      if (!objIsEmpty(tableSchema)) {
+        tablesSchema[tableId] = tableSchema;
+      }
+    });
+    return tablesSchema;
+  };
+  const toValuesSchema = (schemas) => {
+    const valuesSchema = objNew();
+    objForEach(schemas, (typeBoxSchema, valueId) =>
+      ifNotUndefined(toCellOrValueSchema(typeBoxSchema), (valueSchema) => {
+        valuesSchema[valueId] = valueSchema;
+      }),
+    );
+    return valuesSchema;
+  };
+  const toCellOrValueSchema = (typeBoxSchema) => {
+    const [schema, defaultValue, allowNull] = unwrapSchema(typeBoxSchema);
+    const type = schema?.type;
+    if (type !== STRING && type !== NUMBER && type !== BOOLEAN) {
+      return void 0;
+    }
+    const cellOrValueSchema = {[TYPE]: type};
+    ifNotUndefined(defaultValue, (defaultValue2) => {
+      cellOrValueSchema[DEFAULT] = defaultValue2;
+    });
+    if (allowNull) {
+      cellOrValueSchema[ALLOW_NULL] = true;
+    }
+    return cellOrValueSchema;
+  };
+  return objFreeze({
+    toTablesSchema,
+    toValuesSchema,
+  });
+};
+
+export {createTypeBoxSchematizer};

package/schematizers/schematizer-typebox/with-schemas/index.js

@@ -0,0 +1,106 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
+
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value) ? otherwise?.() : then(value);
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const size = (arrayOrString) => arrayOrString.length;
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objForEach = (obj, cb) =>
+  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const ANY_OF = 'anyOf';
+const unwrapSchema = (schema, defaultValue, allowNull) => {
+  if (schema?.[ANY_OF]) {
+    const types = schema[ANY_OF];
+    const hasNull = types.some((t) => t?.type === NULL);
+    const nonNullType = types.find((t) => t?.type !== NULL);
+    if (hasNull && nonNullType) {
+      return unwrapSchema(nonNullType, defaultValue ?? schema?.[DEFAULT], true);
+    }
+  }
+  return [schema, defaultValue ?? schema?.[DEFAULT], allowNull ?? false];
+};
+const createTypeBoxSchematizer = () => {
+  const toTablesSchema = (schemas) => {
+    const tablesSchema = objNew();
+    objForEach(schemas, (typeBoxSchema, tableId) => {
+      const tableSchema = objNew();
+      ifNotUndefined(typeBoxSchema?.properties, (properties) =>
+        objForEach(properties, (cellTypeBoxSchema, cellId) =>
+          ifNotUndefined(
+            toCellOrValueSchema(cellTypeBoxSchema),
+            (cellSchema) => {
+              tableSchema[cellId] = cellSchema;
+            },
+          ),
+        ),
+      );
+      if (!objIsEmpty(tableSchema)) {
+        tablesSchema[tableId] = tableSchema;
+      }
+    });
+    return tablesSchema;
+  };
+  const toValuesSchema = (schemas) => {
+    const valuesSchema = objNew();
+    objForEach(schemas, (typeBoxSchema, valueId) =>
+      ifNotUndefined(toCellOrValueSchema(typeBoxSchema), (valueSchema) => {
+        valuesSchema[valueId] = valueSchema;
+      }),
+    );
+    return valuesSchema;
+  };
+  const toCellOrValueSchema = (typeBoxSchema) => {
+    const [schema, defaultValue, allowNull] = unwrapSchema(typeBoxSchema);
+    const type = schema?.type;
+    if (type !== STRING && type !== NUMBER && type !== BOOLEAN) {
+      return void 0;
+    }
+    const cellOrValueSchema = {[TYPE]: type};
+    ifNotUndefined(defaultValue, (defaultValue2) => {
+      cellOrValueSchema[DEFAULT] = defaultValue2;
+    });
+    if (allowNull) {
+      cellOrValueSchema[ALLOW_NULL] = true;
+    }
+    return cellOrValueSchema;
+  };
+  return objFreeze({
+    toTablesSchema,
+    toValuesSchema,
+  });
+};
+
+export {createTypeBoxSchematizer};

package/schematizers/schematizer-zod/index.js

@@ -0,0 +1,102 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const ALLOW_NULL = 'allowNull';
+
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value) ? otherwise?.() : then(value);
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const size = (arrayOrString) => arrayOrString.length;
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objForEach = (obj, cb) =>
+  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const OPTIONAL = 'optional';
+const NULLABLE = 'nullable';
+const unwrapSchema = (schema, defaultValue, allowNull) => {
+  const type = schema?.def?.type;
+  return type === OPTIONAL
+    ? unwrapSchema(schema.def.innerType, defaultValue, allowNull)
+    : type === NULLABLE
+      ? unwrapSchema(schema.def.innerType, defaultValue, true)
+      : type === DEFAULT
+        ? unwrapSchema(schema.def.innerType, schema.def.defaultValue, allowNull)
+        : [schema, defaultValue, allowNull ?? false];
+};
+const createZodSchematizer = () => {
+  const toTablesSchema = (schemas) => {
+    const tablesSchema = objNew();
+    objForEach(schemas, (zodSchema, tableId) => {
+      const tableSchema = objNew();
+      ifNotUndefined(zodSchema?.def?.shape, (shape) =>
+        objForEach(shape, (cellZodSchema, cellId) =>
+          ifNotUndefined(toCellOrValueSchema(cellZodSchema), (cellSchema) => {
+            tableSchema[cellId] = cellSchema;
+          }),
+        ),
+      );
+      if (!objIsEmpty(tableSchema)) {
+        tablesSchema[tableId] = tableSchema;
+      }
+    });
+    return tablesSchema;
+  };
+  const toValuesSchema = (schemas) => {
+    const valuesSchema = objNew();
+    objForEach(schemas, (zodSchema, valueId) =>
+      ifNotUndefined(toCellOrValueSchema(zodSchema), (valueSchema) => {
+        valuesSchema[valueId] = valueSchema;
+      }),
+    );
+    return valuesSchema;
+  };
+  const toCellOrValueSchema = (zodSchema) => {
+    const [schema, defaultValue, allowNull] = unwrapSchema(zodSchema);
+    const type = schema?.type;
+    if (type !== STRING && type !== NUMBER && type !== BOOLEAN) {
+      return void 0;
+    }
+    const cellOrValueSchema = {[TYPE]: type};
+    ifNotUndefined(defaultValue, (defaultValue2) => {
+      cellOrValueSchema[DEFAULT] = defaultValue2;
+    });
+    if (allowNull) {
+      cellOrValueSchema[ALLOW_NULL] = true;
+    }
+    return cellOrValueSchema;
+  };
+  return objFreeze({
+    toTablesSchema,
+    toValuesSchema,
+  });
+};
+
+export {createZodSchematizer};

package/schematizers/schematizer-zod/with-schemas/index.js

@@ -0,0 +1,102 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const ALLOW_NULL = 'allowNull';
+
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value) ? otherwise?.() : then(value);
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const size = (arrayOrString) => arrayOrString.length;
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objForEach = (obj, cb) =>
+  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const OPTIONAL = 'optional';
+const NULLABLE = 'nullable';
+const unwrapSchema = (schema, defaultValue, allowNull) => {
+  const type = schema?.def?.type;
+  return type === OPTIONAL
+    ? unwrapSchema(schema.def.innerType, defaultValue, allowNull)
+    : type === NULLABLE
+      ? unwrapSchema(schema.def.innerType, defaultValue, true)
+      : type === DEFAULT
+        ? unwrapSchema(schema.def.innerType, schema.def.defaultValue, allowNull)
+        : [schema, defaultValue, allowNull ?? false];
+};
+const createZodSchematizer = () => {
+  const toTablesSchema = (schemas) => {
+    const tablesSchema = objNew();
+    objForEach(schemas, (zodSchema, tableId) => {
+      const tableSchema = objNew();
+      ifNotUndefined(zodSchema?.def?.shape, (shape) =>
+        objForEach(shape, (cellZodSchema, cellId) =>
+          ifNotUndefined(toCellOrValueSchema(cellZodSchema), (cellSchema) => {
+            tableSchema[cellId] = cellSchema;
+          }),
+        ),
+      );
+      if (!objIsEmpty(tableSchema)) {
+        tablesSchema[tableId] = tableSchema;
+      }
+    });
+    return tablesSchema;
+  };
+  const toValuesSchema = (schemas) => {
+    const valuesSchema = objNew();
+    objForEach(schemas, (zodSchema, valueId) =>
+      ifNotUndefined(toCellOrValueSchema(zodSchema), (valueSchema) => {
+        valuesSchema[valueId] = valueSchema;
+      }),
+    );
+    return valuesSchema;
+  };
+  const toCellOrValueSchema = (zodSchema) => {
+    const [schema, defaultValue, allowNull] = unwrapSchema(zodSchema);
+    const type = schema?.type;
+    if (type !== STRING && type !== NUMBER && type !== BOOLEAN) {
+      return void 0;
+    }
+    const cellOrValueSchema = {[TYPE]: type};
+    ifNotUndefined(defaultValue, (defaultValue2) => {
+      cellOrValueSchema[DEFAULT] = defaultValue2;
+    });
+    if (allowNull) {
+      cellOrValueSchema[ALLOW_NULL] = true;
+    }
+    return cellOrValueSchema;
+  };
+  return objFreeze({
+    toTablesSchema,
+    toValuesSchema,
+  });
+};
+
+export {createZodSchematizer};

package/schematizers/with-schemas/index.js

@@ -0,0 +1 @@
+

package/store/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const ADD = 'add';
 const HAS = 'Has';
@@ -62,7 +63,7 @@ const arrayShift = (array) => array.shift();
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/store/with-schemas/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const ADD = 'add';
 const HAS = 'Has';
@@ -62,7 +63,7 @@ const arrayShift = (array) => array.shift();
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/ui-react-dom/index.js

@@ -10,6 +10,7 @@ const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
+const NULL = 'null';
 const LISTENER = 'Listener';
 const RESULT = 'Result';
 const GET = 'get';
@@ -400,7 +401,7 @@ const useResultSortedRowIds = (
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/ui-react-dom/with-schemas/index.js

@@ -10,6 +10,7 @@ const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
+const NULL = 'null';
 const LISTENER = 'Listener';
 const RESULT = 'Result';
 const GET = 'get';
@@ -400,7 +401,7 @@ const useResultSortedRowIds = (
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/ui-react-inspector/index.js

@@ -44,6 +44,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const RESULT = 'Result';
 const GET = 'get';
@@ -663,7 +664,7 @@ const createSessionPersister = (store, storageName, onIgnoredError) =>
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/ui-react-inspector/with-schemas/index.js

@@ -44,6 +44,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const RESULT = 'Result';
 const GET = 'get';
@@ -663,7 +664,7 @@ const createSessionPersister = (store, storageName, onIgnoredError) =>
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/with-schemas/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const SUM = 'sum';
 const AVG = 'avg';
 const MIN = 'min';
@@ -94,7 +95,7 @@ const arrayShift = (array) => array.shift();
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||