tinybase 9.1.0-beta.1 → 9.1.0-beta.2

package/@types/ui-solid/with-schemas/index.d.ts

@@ -143,6 +143,8 @@ import type {
   MapCell,
   MapValue,
   OptionalSchemas,
+  PartialRow,
+  PartialValues,
   Row,
   RowCountListener,
   RowIdsListener,
@@ -2691,13 +2693,13 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetTablesCallback: <Parameter, SetTables = Tables<Schemas[0], true>>(
+  useSetTablesCallback: <Parameter>(
     getTables: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTables>,
+    ) => Tables<Schemas[0], true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, tables: SetTables) => void,
+    then?: (store: Store<Schemas>, tables: Tables<Schemas[0], true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -2803,15 +2805,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetTableCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetTable = Table<Schemas[0], TableId, true>,
   >(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     getTable: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTable>,
+    ) => Table<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, table: SetTable) => void,
+    then?: (
+      store: Store<Schemas>,
+      table: Table<Schemas[0], TableId, true>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -2917,16 +2921,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    SetRow = Row<Schemas[0], TableId, true>,
-  >(
+  useSetRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     rowId: MaybeAccessor<Id> | GetId<Schemas, Parameter, Id>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<SetRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, row: SetRow) => void,
+    then?: (store: Store<Schemas>, row: Row<Schemas[0], TableId, true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3039,15 +3042,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useAddRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    AddRow = Row<Schemas[0], TableId, true>,
-  >(
+  useAddRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<AddRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (rowId: Id | undefined, store: Store<Schemas>, row: AddRow) => void,
+    then?: (
+      rowId: Id | undefined,
+      store: Store<Schemas>,
+      row: Row<Schemas[0], TableId, true>,
+    ) => void,
     reuseRowIds?: boolean,
   ) => ParameterizedCallback<Parameter>;
 
@@ -3158,16 +3164,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetPartialRowCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetPartialRow = Row<Schemas[0], TableId, true>,
   >(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     rowId: MaybeAccessor<Id> | GetId<Schemas, Parameter, Id>,
     getPartialRow: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialRow>,
+    ) => PartialRow<Schemas[0], TableId>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, partialRow: SetPartialRow) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialRow: PartialRow<Schemas[0], TableId>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3353,13 +3361,13 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetValuesCallback: <Parameter, SetValues = Values<Schemas[1], true>>(
+  useSetValuesCallback: <Parameter>(
     getValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetValues>,
+    ) => Values<Schemas[1], true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, values: SetValues) => void,
+    then?: (store: Store<Schemas>, values: Values<Schemas[1], true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3460,16 +3468,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetPartialValuesCallback: <
-    Parameter,
-    SetPartialValues = Values<Schemas[1], true>,
-  >(
+  useSetPartialValuesCallback: <Parameter>(
     getPartialValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialValues>,
+    ) => PartialValues<Schemas[1]>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, partialValues: SetPartialValues) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialValues: PartialValues<Schemas[1]>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -7827,6 +7835,35 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
   ): Accessor<Ids>;
 
+  /**
+ * The useHasIndex primitive returns a boolean indicating whether a given Index
+ * exists in the Indexes object, and registers a listener so that any changes to
+ * that result will cause an update.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasIndex(
+ *   indexId: MaybeAccessor<Id>,
+ *   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+ * ): Accessor<boolean>;
+ * ```
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useIndexIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether an Index with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+  useHasIndex: (
+    indexId: MaybeAccessor<Id>,
+    indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => Accessor<boolean>;
+
   /**
  * The useSliceIds primitive gets the list of Slice Ids in an Index, and
  * registers a listener so that any changes to that result will cause an update.
@@ -7923,6 +7960,38 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
   ) => Accessor<Ids>;
 
+  /**
+ * The useHasSlice primitive returns a boolean indicating whether a given Slice
+ * exists in an Index, and registers a listener so that any changes to that
+ * result will cause an update.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasSlice(
+ *   indexId: MaybeAccessor<Id>,
+ *   sliceId: MaybeAccessor<Id>,
+ *   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+ * ): Accessor<boolean>;
+ * ```
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useSliceIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param sliceId The Id of a possible Slice in the Index.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether a Slice with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+  useHasSlice: (
+    indexId: MaybeAccessor<Id>,
+    sliceId: MaybeAccessor<Id>,
+    indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => Accessor<boolean>;
+
   /**
  * The useSliceRowIds primitive gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause an update.

package/@types/ui-svelte/index.d.ts

@@ -4237,6 +4237,22 @@ export function getIndexIds(
   readonly current: Ids;
 };
 
+/**
+ * The hasIndex function returns a reactive object reflecting whether a given
+ * Index exists in the Indexes object, and registers a listener so that any
+ * changes will update `current`.
+ * @param indexId The Id of the possible Index (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+export function hasIndex(
+  indexId: MaybeGetter<Id>,
+  indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
+): {readonly current: boolean};
+
 /**
  * The getSliceIds function returns a reactive object reflecting the Ids of the
  * Slices in an Index, and registers a listener so that any changes will update
@@ -4295,6 +4311,24 @@ export function getSliceIds(
   indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
 ): {readonly current: Ids};
 
+/**
+ * The hasSlice function returns a reactive object reflecting whether a given
+ * Slice exists in an Index, and registers a listener so that any changes will
+ * update `current`.
+ * @param indexId The Id of the Index (or a getter returning it).
+ * @param sliceId The Id of the possible Slice (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+export function hasSlice(
+  indexId: MaybeGetter<Id>,
+  sliceId: MaybeGetter<Id>,
+  indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
+): {readonly current: boolean};
+
 /**
  * The getSliceRowIds function returns a reactive object reflecting the Ids of
  * the Rows in a Slice, and registers a listener so that any changes will update

package/@types/ui-svelte/with-schemas/index.d.ts

@@ -4718,6 +4718,22 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     readonly current: Ids;
   };
 
+  /**
+ * The hasIndex function returns a reactive object reflecting whether a given
+ * Index exists in the Indexes object, and registers a listener so that any
+ * changes will update `current`.
+ * @param indexId The Id of the possible Index (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+  hasIndex: (
+    indexId: MaybeGetter<Id>,
+    indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => {readonly current: boolean};
+
   /**
  * The getSliceIds function returns a reactive object reflecting the Ids of the
  * Slices in an Index, and registers a listener so that any changes will update
@@ -4785,6 +4801,24 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => {readonly current: Ids};
 
+  /**
+ * The hasSlice function returns a reactive object reflecting whether a given
+ * Slice exists in an Index, and registers a listener so that any changes will
+ * update `current`.
+ * @param indexId The Id of the Index (or a getter returning it).
+ * @param sliceId The Id of the possible Slice (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+  hasSlice: (
+    indexId: MaybeGetter<Id>,
+    sliceId: MaybeGetter<Id>,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => {readonly current: boolean};
+
   /**
  * The getSliceRowIds function returns a reactive object reflecting the Ids of
  * the Rows in a Slice, and registers a listener so that any changes will update

package/index.js

@@ -35,6 +35,7 @@ const VALUE = 'Value';
 const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
 const TRANSACTION = 'Transaction';
+const REQUIRED = 'required';
 const JSON_PREFIX = '\uFFFD';
 const id = (key) => EMPTY_STRING + key;
 const strStartsWith = (str, prefix) => str.startsWith(prefix);
@@ -929,7 +930,9 @@ const defaultSorter = (sortKey1, sortKey2) =>
   (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
 
 const createIndexes = getCreateFunction((store) => {
+  const hasIndexListeners = mapNew();
   const sliceIdsListeners = mapNew();
+  const hasSliceListeners = mapNew();
   const sliceRowIdsListeners = mapNew();
   const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
     () => indexes,
@@ -968,6 +971,7 @@ const createIndexes = getCreateFunction((store) => {
     sliceIdSorter,
     rowIdSorter = defaultSorter,
   ) => {
+    const hadIndex = hasIndex(indexId);
     const sliceIdArraySorter = isUndefined(sliceIdSorter)
       ? void 0
       : ([id1], [id2]) => sliceIdSorter(id1, id2);
@@ -984,8 +988,14 @@ const createIndexes = getCreateFunction((store) => {
       ) => {
         let sliceIdsChanged = 0;
         const changedSlices = setNew();
+        const hadSlices = mapNew();
         const unsortedSlices = setNew();
         const index = getIndex(indexId);
+        const setHadSlice = (sliceId) => {
+          if (!collHas(hadSlices, sliceId)) {
+            mapSet(hadSlices, sliceId, collHas(index, sliceId));
+          }
+        };
         collForEach(
           changedSliceIds,
           ([oldSliceIdOrIds, newSliceIdOrIds], rowId) => {
@@ -997,6 +1007,7 @@ const createIndexes = getCreateFunction((store) => {
                 : 0,
             );
             collForEach(oldSliceIds, (oldSliceId) => {
+              setHadSlice(oldSliceId);
               setAdd(changedSlices, oldSliceId);
               ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {
                 collDel(oldSlice, rowId);
@@ -1007,6 +1018,7 @@ const createIndexes = getCreateFunction((store) => {
               });
             });
             collForEach(newSliceIds, (newSliceId) => {
+              setHadSlice(newSliceId);
               setAdd(changedSlices, newSliceId);
               if (!collHas(index, newSliceId)) {
                 mapSet(index, newSliceId, setNew());
@@ -1068,6 +1080,12 @@ const createIndexes = getCreateFunction((store) => {
         if (sliceIdsChanged) {
           callListeners(sliceIdsListeners, [indexId]);
         }
+        mapForEach(hadSlices, (sliceId, hadSlice) => {
+          const hasSliceNow = collHas(index, sliceId);
+          if (hadSlice != hasSliceNow) {
+            callListeners(hasSliceListeners, [indexId, sliceId], hasSliceNow);
+          }
+        });
         collForEach(changedSlices, (sliceId) =>
           callListeners(sliceRowIdsListeners, [indexId, sliceId]),
         );
@@ -1075,6 +1093,9 @@ const createIndexes = getCreateFunction((store) => {
       getRowCellFunction(getSliceIdOrIds),
       ifNotUndefined(getSortKey, getRowCellFunction),
     );
+    if (!hadIndex) {
+      callListeners(hasIndexListeners, [indexId], true);
+    }
     return indexes;
   };
   const forEachIndex = (indexCallback) =>
@@ -1098,7 +1119,20 @@ const createIndexes = getCreateFunction((store) => {
     );
   };
   const delIndexDefinition = (indexId) => {
+    const index = getIndex(indexId);
+    const hadIndex = hasIndex(indexId);
+    const sliceIds = hadIndex ? mapKeys(index) : [];
     delDefinition(indexId);
+    if (hadIndex) {
+      callListeners(hasIndexListeners, [indexId], false);
+      if (sliceIds.length > 0) {
+        callListeners(sliceIdsListeners, [indexId]);
+        arrayForEach(sliceIds, (sliceId) => {
+          callListeners(hasSliceListeners, [indexId, sliceId], false);
+          callListeners(sliceRowIdsListeners, [indexId, sliceId]);
+        });
+      }
+    }
     return indexes;
   };
   const getSliceIds = (indexId) => mapKeys(getIndex(indexId));
@@ -1106,6 +1140,10 @@ const createIndexes = getCreateFunction((store) => {
     collValues(mapGet(getIndex(indexId), sliceId));
   const addSliceIdsListener = (indexId, listener) =>
     addListener(listener, sliceIdsListeners, [indexId]);
+  const addHasIndexListener = (indexId, listener) =>
+    addListener(listener, hasIndexListeners, [indexId]);
+  const addHasSliceListener = (indexId, sliceId, listener) =>
+    addListener(listener, hasSliceListeners, [indexId, sliceId]);
   const addSliceRowIdsListener = (indexId, sliceId, listener) =>
     addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);
   const delListener = (listenerId) => {
@@ -1129,7 +1167,9 @@ const createIndexes = getCreateFunction((store) => {
     getSliceIds,
     getSliceRowIds,
     addIndexIdsListener,
+    addHasIndexListener,
     addSliceIdsListener,
+    addHasSliceListener,
     addSliceRowIdsListener,
     delListener,
     destroy,
@@ -1236,6 +1276,7 @@ const createStore = () => {
   const valuesSchemaMap = mapNew();
   const valuesDefaulted = mapNew();
   const valuesNonDefaulted = setNew();
+  const valuesRequiredNonDefaulted = setNew();
   const tablePoolFunctions = mapNew();
   const tableCellIds = mapNew();
   const tablesMap = mapNew();
@@ -1288,7 +1329,7 @@ const createStore = () => {
   const validateCellOrValueSchema = (schema) => {
     if (
       !objValidate(schema, (_child, id2) =>
-        arrayHas([TYPE, DEFAULT, ALLOW_NULL], id2),
+        arrayHas([TYPE, DEFAULT, ALLOW_NULL, REQUIRED], id2),
       )
     ) {
       return false;
@@ -1323,20 +1364,32 @@ const createStore = () => {
       (row, rowId) => validateRow(tableId, rowId, row),
       () => cellInvalid(tableId),
     );
-  const validateRow = (tableId, rowId, row, skipDefaults) =>
-    objValidate(
-      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
-      (cell, cellId) =>
-        ifNotUndefined(
-          getValidatedCell(tableId, rowId, cellId, cell),
-          (validCell) => {
-            row[cellId] = validCell;
-            return true;
-          },
-          () => false,
-        ),
-      () => cellInvalid(tableId, rowId),
+  const validateRow = (tableId, rowId, row, skipDefaults) => {
+    const rowWithDefaults = skipDefaults
+      ? row
+      : addDefaultsToRow(row, tableId, rowId);
+    return (
+      objValidate(
+        rowWithDefaults,
+        (cell, cellId) =>
+          ifNotUndefined(
+            getValidatedCell(tableId, rowId, cellId, cell),
+            (validCell) => {
+              row[cellId] = validCell;
+              return true;
+            },
+            () => false,
+          ),
+        () => cellInvalid(tableId, rowId),
+      ) &&
+      (skipDefaults
+        ? true
+        : arrayEvery(
+            collValues(mapGet(tablesSchemaRowCache, tableId)?.[2]),
+            (cellId) => objHas(rowWithDefaults, cellId),
+          ))
     );
+  };
   const getValidatedCell = (tableId, rowId, cellId, cell) =>
     hasTablesSchema
       ? ifNotUndefined(
@@ -1362,20 +1415,31 @@ const createStore = () => {
       : isUndefined(getCellOrValueType(cell))
         ? cellInvalid(tableId, rowId, cellId, cell)
         : encodeIfJson(cell);
-  const validateValues = (values, skipDefaults) =>
-    objValidate(
-      skipDefaults ? values : addDefaultsToValues(values),
-      (value, valueId) =>
-        ifNotUndefined(
-          getValidatedValue(valueId, value),
-          (validValue) => {
-            values[valueId] = validValue;
-            return true;
-          },
-          () => false,
-        ),
-      () => valueInvalid(),
+  const validateValues = (values, skipDefaults) => {
+    const valuesWithDefaults = skipDefaults
+      ? values
+      : addDefaultsToValues(values);
+    return (
+      objValidate(
+        valuesWithDefaults,
+        (value, valueId) =>
+          ifNotUndefined(
+            getValidatedValue(valueId, value),
+            (validValue) => {
+              values[valueId] = validValue;
+              return true;
+            },
+            () => false,
+          ),
+        () => valueInvalid(),
+      ) &&
+      (skipDefaults
+        ? true
+        : arrayEvery(collValues(valuesRequiredNonDefaulted), (valueId) =>
+            objHas(valuesWithDefaults, valueId),
+          ))
     );
+  };
   const getValidatedValue = (valueId, value) =>
     hasValuesSchema
       ? ifNotUndefined(
@@ -1446,6 +1510,7 @@ const createStore = () => {
       (_tablesSchema, tableId, tableSchema) => {
         const rowDefaulted = mapNew();
         const rowNonDefaulted = setNew();
+        const rowRequiredNonDefaulted = setNew();
         mapMatch(
           mapEnsure(tablesSchemaMap, tableId, mapNew),
           tableSchema,
@@ -1453,12 +1518,23 @@ const createStore = () => {
             mapSet(tableSchemaMap, cellId, cellSchema);
             ifNotUndefined(
               cellSchema[DEFAULT],
-              (def) => mapSet(rowDefaulted, cellId, def),
-              () => setAdd(rowNonDefaulted, cellId),
+              (defaultCell) => {
+                mapSet(rowDefaulted, cellId, defaultCell);
+              },
+              () => {
+                setAdd(rowNonDefaulted, cellId);
+                if (cellSchema[REQUIRED] === true) {
+                  setAdd(rowRequiredNonDefaulted, cellId);
+                }
+              },
             );
           },
         );
-        mapSet(tablesSchemaRowCache, tableId, [rowDefaulted, rowNonDefaulted]);
+        mapSet(tablesSchemaRowCache, tableId, [
+          rowDefaulted,
+          rowNonDefaulted,
+          rowRequiredNonDefaulted,
+        ]);
       },
       (_tablesSchema, tableId) => {
         mapSet(tablesSchemaMap, tableId);
@@ -1473,14 +1549,27 @@ const createStore = () => {
         mapSet(valuesSchemaMap, valueId, valueSchema);
         ifNotUndefined(
           valueSchema[DEFAULT],
-          (def) => mapSet(valuesDefaulted, valueId, def),
-          () => setAdd(valuesNonDefaulted, valueId),
+          (defaultValue) => {
+            mapSet(valuesDefaulted, valueId, defaultValue);
+            collDel(valuesNonDefaulted, valueId);
+            collDel(valuesRequiredNonDefaulted, valueId);
+          },
+          () => {
+            mapSet(valuesDefaulted, valueId);
+            setAdd(valuesNonDefaulted, valueId);
+            if (valueSchema[REQUIRED] === true) {
+              setAdd(valuesRequiredNonDefaulted, valueId);
+            } else {
+              collDel(valuesRequiredNonDefaulted, valueId);
+            }
+          },
         );
       },
       (_valuesSchema, valueId) => {
         mapSet(valuesSchemaMap, valueId);
         mapSet(valuesDefaulted, valueId);
         collDel(valuesNonDefaulted, valueId);
+        collDel(valuesRequiredNonDefaulted, valueId);
       },
     );
   const setOrDelTables = (tables) =>