@rljson/rljson 0.0.51 → 0.0.53

package/dist/rljson.js

@@ -1,11 +1,9 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { hip, hsh } from "@rljson/hash";
 import { exampleJsonObject, jsonValueTypes, jsonValueType, jsonValueMatchesType } from "@rljson/json";
 // @license
 const bakeryExample = () => {
   const nutritionalValues = hip({
+    _type: "components",
     _data: [
       {
         id: "flour",
@@ -27,6 +25,7 @@ const bakeryExample = () => {
     _hash: ""
   });
   const ingredients = hip({
+    _type: "components",
     _data: [
       {
         id: "flour",
@@ -38,6 +37,7 @@ const bakeryExample = () => {
     _hash: ""
   });
   const recipeIngredients = hip({
+    _type: "components",
     _data: [
       {
         id: "flour",
@@ -49,6 +49,7 @@ const bakeryExample = () => {
     _hash: ""
   });
   const slices = hip({
+    _type: "sliceIds",
     _data: [
       {
         add: ["slice0", "slice1"],
@@ -57,6 +58,7 @@ const bakeryExample = () => {
     ]
   });
   const ingredientTypes = hip({
+    _type: "sliceIds",
     _data: [
       {
         add: ["flour"],
@@ -65,26 +67,28 @@ const bakeryExample = () => {
     ]
   });
   const recipes = hip({
+    _type: "layers",
     _data: [
       {
         id: "tastyCake",
-        ingredientsTable: "recipeIngredients",
+        componentsTable: "recipeIngredients",
         sliceIdsTable: "ingredientTypes",
         sliceIdsTableRow: ingredientTypes._data[0]._hash,
-        assign: {
+        add: {
           flour: recipeIngredients._data[0]._hash
         },
         _hash: ""
       }
     ]
   });
-  const layers = hip({
+  const recipeLayers = hip({
+    _type: "layers",
     _data: [
       {
-        ingredientsTable: "recipes",
+        componentsTable: "recipes",
         sliceIdsTable: "slices",
         sliceIdsTableRow: slices._data[0]._hash,
-        assign: {
+        add: {
           slice0: recipes._data[0]._hash,
           slice1: recipes._data[0]._hash
         }
@@ -92,19 +96,20 @@ const bakeryExample = () => {
     ]
   });
   const cakes = hip({
+    _type: "cakes",
     _data: [
       {
         id: "cake1",
         sliceIdsTable: "slices",
         sliceIdsRow: slices._data[0]._hash,
-        layersTable: "layers",
         layers: {
-          flour: layers._data[0]._hash
+          recipeLayers: recipeLayers._data[0]._hash
         }
       }
     ]
   });
   const buffets = hip({
+    _type: "buffets",
     _data: [
       {
         id: "salesCounter",
@@ -122,7 +127,7 @@ const bakeryExample = () => {
     cakes,
     slices,
     ingredientTypes,
-    layers,
+    recipeLayers,
     recipes,
     recipeIngredients,
     ingredients,
@@ -135,9 +140,9 @@ const exampleBuffetsTable = () => bakeryExample().buffets;
 // @license
 const exampleCakesTable = () => bakeryExample().cakes;
 // @license
-const exampleIngredientsTable = () => bakeryExample().nutritionalValues;
+const exampleComponentsTable = () => bakeryExample().nutritionalValues;
 // @license
-const exampleLayersTable = () => bakeryExample().layers;
+const exampleLayersTable = () => bakeryExample().recipeLayers;
 // @license
 const exampleRevision = () => ({
   table: "nutritionalValues",
@@ -149,230 +154,120 @@ const exampleRevision = () => ({
 // @license
 const exampleSliceIdsTable = () => bakeryExample().slices;
 // @license
-const _Example = class _Example {
-};
-__publicField(_Example, "ok", {
-  bakery: () => bakeryExample(),
-  empty: () => {
-    return {};
-  },
-  binary: () => {
-    return {
-      table: {
-        _data: [
-          { a: false, b: false },
-          { a: false, b: true },
-          { a: true, b: false },
-          { a: true, b: true }
-        ]
-      }
-    };
-  },
-  singleRow: () => {
-    const tableCfgs = hip({
-      _hash: "",
-      _data: [
-        {
-          version: 0,
-          _hash: "",
-          key: "table",
-          type: "ingredients",
-          isHead: false,
-          isRoot: false,
-          isShared: true,
-          columns: [
-            {
-              key: "int",
-              type: "number"
-            },
-            {
-              key: "double",
-              type: "number"
-            },
-            {
-              key: "string",
-              type: "string"
-            },
-            {
-              key: "boolean",
-              type: "boolean"
-            },
-            {
-              key: "null",
-              type: "string"
-            },
-            {
-              key: "jsonArray",
-              type: "jsonArray"
-            },
-            {
-              key: "json",
-              type: "json"
-            },
-            {
-              key: "jsonValue",
-              type: "jsonValue"
-            }
+class Example {
+  static ok = {
+    bakery: () => bakeryExample(),
+    empty: () => {
+      return {};
+    },
+    binary: () => {
+      return {
+        table: {
+          _type: "components",
+          _data: [
+            { a: false, b: false },
+            { a: false, b: true },
+            { a: true, b: false },
+            { a: true, b: true }
           ]
         }
-      ]
-    });
-    const result = {
-      tableCfgs,
-      table: {
-        _tableCfg: tableCfgs._data[0]._hash,
-        _data: [exampleJsonObject()],
-        _hash: ""
-      }
-    };
-    return result;
-  },
-  multipleRows: () => {
-    return {
-      table: {
-        _data: [
-          {
-            string: "str0",
-            boolean: true,
-            number: 1,
-            array: [1, "str0", true, { a: { b: "c" } }],
-            object: { a: { b: "c" } }
-          },
-          {
-            string: "str1",
-            boolean: true,
-            number: 1,
-            array: [1, "str1", true, { a: { b: "c" } }],
-            object: { a: { b: "c" } }
-          },
-          {
-            string: "str2",
-            boolean: false,
-            number: 1,
-            array: [1, "str1", true, { a: { b: "c" } }],
-            object: { d: { e: "f" } }
-          }
-        ]
-      }
-    };
-  },
-  singleRef: () => {
-    return {
-      tableA: {
-        _data: [
-          {
-            keyA0: "a0"
-          },
-          {
-            keyA1: "a1"
-          }
-        ]
-      },
-      tableB: {
+      };
+    },
+    singleRow: () => {
+      const tableCfgs = hip({
+        _hash: "",
+        _type: "tableCfgs",
         _data: [
           {
-            tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
+            version: 0,
+            _hash: "",
+            key: "table",
+            type: "components",
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: "int",
+                type: "number"
+              },
+              {
+                key: "double",
+                type: "number"
+              },
+              {
+                key: "string",
+                type: "string"
+              },
+              {
+                key: "boolean",
+                type: "boolean"
+              },
+              {
+                key: "null",
+                type: "string"
+              },
+              {
+                key: "jsonArray",
+                type: "jsonArray"
+              },
+              {
+                key: "json",
+                type: "json"
+              },
+              {
+                key: "jsonValue",
+                type: "jsonValue"
+              }
+            ]
           }
         ]
-      }
-    };
-  },
-  complete: () => {
-    const sliceIds = hip({
-      _data: [
-        {
-          add: ["id0", "id1"]
+      });
+      const result = {
+        tableCfgs,
+        table: {
+          _tableCfg: tableCfgs._data[0]._hash,
+          _type: "components",
+          _data: [exampleJsonObject()],
+          _hash: ""
         }
-      ]
-    });
-    const ingredients = hip({
-      _data: [{ a: "0" }, { a: "1" }]
-    });
-    const ingredient0 = ingredients._data[0];
-    const ingredient1 = ingredients._data[1];
-    const layer0 = hip({
-      sliceIdsTable: "sliceIds",
-      sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
-      ingredientsTable: "ingredients",
-      assign: {
-        id0: ingredient0._hash,
-        id1: ingredient1._hash
-      }
-    });
-    const layer1 = hip({
-      base: layer0._hash,
-      sliceIdsTable: "sliceIds",
-      sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
-      ingredientsTable: "ingredients",
-      assign: {
-        id0: ingredient0._hash,
-        id1: ingredient1._hash
-      }
-    });
-    const layers = hip({
-      _data: [layer0, layer1]
-    });
-    const cake = hip({
-      sliceIdsTable: "sliceIds",
-      sliceIdsRow: sliceIds._data[0]._hash,
-      layersTable: "layers",
-      layers: {
-        layer0: layer0._hash,
-        layer1: layer1._hash
-      }
-    });
-    const cakes = hip({
-      _data: [cake]
-    });
-    const buffets = hip({
-      _data: [
-        {
-          items: [
+      };
+      return result;
+    },
+    multipleRows: () => {
+      return {
+        table: {
+          _type: "components",
+          _data: [
+            {
+              string: "str0",
+              boolean: true,
+              number: 1,
+              array: [1, "str0", true, { a: { b: "c" } }],
+              object: { a: { b: "c" } }
+            },
             {
-              table: "cakes",
-              ref: cakes._data[0]._hash
+              string: "str1",
+              boolean: true,
+              number: 1,
+              array: [1, "str1", true, { a: { b: "c" } }],
+              object: { a: { b: "c" } }
             },
             {
-              table: "layers",
-              ref: layer0._hash
+              string: "str2",
+              boolean: false,
+              number: 1,
+              array: [1, "str1", true, { a: { b: "c" } }],
+              object: { d: { e: "f" } }
             }
           ]
         }
-      ]
-    });
-    return {
-      sliceIds,
-      ingredients,
-      layers,
-      cakes,
-      buffets
-    };
-  }
-});
-__publicField(_Example, "broken", {
-  base: {
-    brokenTableKey: () => {
-      return {
-        brok$en: {
-          _data: []
-        }
-      };
-    },
-    missingData: () => {
-      return {
-        table: {}
       };
     },
-    dataNotBeingAnArray: () => {
-      return {
-        table: {
-          _data: {}
-        }
-      };
-    },
-    missingRef: () => {
+    singleRef: () => {
       return {
         tableA: {
+          _type: "components",
           _data: [
             {
               keyA0: "a0"
@@ -383,128 +278,248 @@ __publicField(_Example, "broken", {
           ]
         },
         tableB: {
+          _type: "components",
           _data: [
             {
-              tableARef: "MISSINGREF"
-              // MISSINGREF does not exist in tableA
+              tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
             }
           ]
         }
       };
     },
-    missingReferencedTable: () => {
-      return {
-        tableB: {
-          _data: [
-            {
-              tableARef: "MISSINGREF"
-              // tableA is missing
-            }
-          ]
-        }
-      };
-    }
-  },
-  tableCfg: {
-    wrongType: () => {
-      const result = _Example.ok.singleRow();
-      const columns = result.tableCfgs._data[0].columns;
-      const intColumn = columns.find((c) => c.key === "int");
-      intColumn.type = "numberBroken";
-      return hip(result, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+    complete: () => {
+      const sliceIds = hip({
+        _type: "sliceIds",
+        _data: [
+          {
+            add: ["id0", "id1"]
+          }
+        ]
       });
-    }
-  },
-  layers: {
-    missingBase: () => {
-      const result = _Example.ok.complete();
-      const layer1 = result.layers._data[1];
-      layer1.base = "MISSING";
-      return hip(result, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const components = hip({
+        _type: "components",
+        _data: [{ a: "0" }, { a: "1" }]
       });
-    },
-    missingSliceIdSet: () => {
-      const result = _Example.ok.complete();
-      const layer1 = result.layers._data[1];
-      layer1.sliceIdsTableRow = "MISSING1";
-      return hip(result, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const component0 = components._data[0];
+      const component1 = components._data[1];
+      const abLayer0 = hip({
+        sliceIdsTable: "sliceIds",
+        sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
+        componentsTable: "components",
+        add: {
+          id0: component0._hash,
+          id1: component1._hash
+        }
       });
-    },
-    missingAssignedIngredientTable: () => {
-      const result = _Example.ok.complete();
-      delete result.ingredients;
-      return result;
-    },
-    missingAssignedIngredient: () => {
-      const result = _Example.ok.complete();
-      result.ingredients._data.splice(1, 2);
-      return hip(result, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const abLayer1 = hip({
+        base: abLayer0._hash,
+        sliceIdsTable: "sliceIds",
+        sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
+        componentsTable: "components",
+        add: {
+          id0: component0._hash,
+          id1: component1._hash
+        }
       });
-    }
-  },
-  cakes: {
-    missingSliceIdSet: () => {
-      const result = _Example.ok.complete();
-      result.cakes._data[0].sliceIdsRow = "MISSING";
-      hip(result.cakes, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const abLayers = hip({
+        _type: "layers",
+        _data: [abLayer0, abLayer1]
       });
-      result.buffets._data[0].items[0].ref = result.cakes._data[0]._hash;
-      hip(result.buffets, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const cake = hip({
+        sliceIdsTable: "sliceIds",
+        sliceIdsRow: sliceIds._data[0]._hash,
+        layers: {
+          abLayers: abLayer1._hash
+        }
       });
-      return result;
-    },
-    missingLayersTable: () => {
-      const result = _Example.ok.complete();
-      result.cakes._data[0].layersTable = "MISSING";
-      hip(result.cakes, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const cakes = hip({
+        _type: "cakes",
+        _data: [cake]
       });
-      return result;
-    },
-    missingCakeLayer: () => {
-      const result = _Example.ok.complete();
-      result.cakes._data[0].layers["layer0"] = "MISSING0";
-      result.cakes._data[0].layers["layer1"] = "MISSING1";
-      hip(result.cakes, {
-        updateExistingHashes: true,
-        throwOnWrongHashes: false
+      const buffets = hip({
+        _type: "buffets",
+        _data: [
+          {
+            items: [
+              {
+                table: "cakes",
+                ref: cakes._data[0]._hash
+              },
+              {
+                table: "abLayers",
+                ref: abLayer0._hash
+              }
+            ]
+          }
+        ]
       });
-      return result;
+      return {
+        sliceIds,
+        components,
+        abLayers,
+        cakes,
+        buffets
+      };
     }
-  },
-  buffets: {
-    missingTable: () => {
-      const result = _Example.ok.complete();
-      const buffet = result.buffets._data[0];
-      buffet.items[0].table = "MISSING0";
-      buffet.items[1].table = "MISSING1";
-      hip(result, { updateExistingHashes: true, throwOnWrongHashes: false });
-      return result;
+  };
+  static broken = {
+    base: {
+      brokenTableKey: () => {
+        return {
+          brok$en: {
+            _data: []
+          }
+        };
+      },
+      missingData: () => {
+        return {
+          table: {}
+        };
+      },
+      dataNotBeingAnArray: () => {
+        return {
+          table: {
+            _data: {}
+          }
+        };
+      },
+      missingRef: () => {
+        return {
+          tableA: {
+            _type: "components",
+            _data: [
+              {
+                keyA0: "a0"
+              },
+              {
+                keyA1: "a1"
+              }
+            ]
+          },
+          tableB: {
+            _type: "components",
+            _data: [
+              {
+                tableARef: "MISSINGREF"
+                // MISSINGREF does not exist in tableA
+              }
+            ]
+          }
+        };
+      },
+      missingReferencedTable: () => {
+        return {
+          tableB: {
+            _type: "components",
+            _data: [
+              {
+                tableARef: "MISSINGREF"
+                // tableA is missing
+              }
+            ]
+          }
+        };
+      }
     },
-    missingItems: () => {
-      const result = _Example.ok.complete();
-      const buffet = result.buffets._data[0];
-      buffet.items[0].ref = "MISSING0";
-      buffet.items[1].ref = "MISSING1";
-      hip(result, { updateExistingHashes: true, throwOnWrongHashes: false });
-      return result;
+    tableCfg: {
+      wrongType: () => {
+        const result = Example.ok.singleRow();
+        const columns = result.tableCfgs._data[0].columns;
+        const intColumn = columns.find((c) => c.key === "int");
+        intColumn.type = "numberBroken";
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      }
+    },
+    layers: {
+      missingBase: () => {
+        const result = Example.ok.complete();
+        const layer1 = result.abLayers._data[1];
+        layer1.base = "MISSING";
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      },
+      missingSliceIdSet: () => {
+        const result = Example.ok.complete();
+        const layer1 = result.abLayers._data[1];
+        layer1.sliceIdsTableRow = "MISSING1";
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      },
+      missingAssignedComponentTable: () => {
+        const result = Example.ok.complete();
+        delete result.components;
+        return result;
+      },
+      missingAssignedComponent: () => {
+        const result = Example.ok.complete();
+        result.components._data.splice(1, 2);
+        return hip(result, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+      }
+    },
+    cakes: {
+      missingSliceIdSet: () => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].sliceIdsRow = "MISSING";
+        hip(result.cakes, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+        result.buffets._data[0].items[0].ref = result.cakes._data[0]._hash;
+        hip(result.buffets, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+        return result;
+      },
+      missingLayersTable: () => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].layers = { MISSING: "HASH" };
+        hip(result.cakes, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+        return result;
+      },
+      missingCakeLayer: () => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].layers["abLayers"] = "MISSING0";
+        hip(result.cakes, {
+          updateExistingHashes: true,
+          throwOnWrongHashes: false
+        });
+        return result;
+      }
+    },
+    buffets: {
+      missingTable: () => {
+        const result = Example.ok.complete();
+        const buffet = result.buffets._data[0];
+        buffet.items[0].table = "MISSING0";
+        buffet.items[1].table = "MISSING1";
+        hip(result, { updateExistingHashes: true, throwOnWrongHashes: false });
+        return result;
+      },
+      missingItems: () => {
+        const result = Example.ok.complete();
+        const buffet = result.buffets._data[0];
+        buffet.items[0].ref = "MISSING0";
+        buffet.items[1].ref = "MISSING1";
+        hip(result, { updateExistingHashes: true, throwOnWrongHashes: false });
+        return result;
+      }
     }
-  }
-});
-let Example = _Example;
+  };
+}
 // @license
 const throwOnInvalidTableCfg = (tableCfg) => {
   if (tableCfg.columns.length < 2) {
@@ -583,8 +598,8 @@ const addColumnsToTableCfg = (tableCfg, columns) => {
 const exampleTableCfgTable = () => Example.ok.singleRow().tableCfgs;
 const exampleTableCfg = (tableCfg = void 0) => {
   return {
-    key: (tableCfg == null ? void 0 : tableCfg.key) ?? "table",
-    columns: (tableCfg == null ? void 0 : tableCfg.columns) ?? [
+    key: tableCfg?.key ?? "table",
+    columns: tableCfg?.columns ?? [
       {
         key: "_hash",
         type: "string"
@@ -598,36 +613,13 @@ const exampleTableCfg = (tableCfg = void 0) => {
         type: "number"
       }
     ],
-    type: (tableCfg == null ? void 0 : tableCfg.type) ?? "ingredients",
+    type: tableCfg?.type ?? "components",
     isHead: true,
     isRoot: true,
     isShared: false
   };
 };
 // @license
-const rljsonIndexed = (rljson) => {
-  const result = {};
-  for (const key in rljson) {
-    const slice = rljson[key];
-    if (typeof slice != "object") {
-      result[key] = slice;
-      continue;
-    }
-    const dataIndexed = {};
-    result[key] = { ...slice };
-    if (!Array.isArray(slice._data)) {
-      continue;
-    }
-    for (const row of slice._data) {
-      const hashedRow = row._hash ? row : hsh(row);
-      const hash = hashedRow._hash;
-      dataIndexed[hash] = hashedRow;
-    }
-    result[key]._data = dataIndexed;
-  }
-  return result;
-};
-// @license
 const reservedFieldNames = ["_data"];
 const reservedTableKeys = [
   "_hash",
@@ -668,12 +660,28 @@ const iterateTables = async (rljson, callback) => {
   }
 };
 // @license
+const removeDuplicates = (rljson) => {
+  const result = {};
+  for (const key in rljson) {
+    if (key.startsWith("_")) continue;
+    const table = rljson[key];
+    const data = table._data;
+    const newData = Array.from(
+      new Map(data.map((row) => [row._hash, row])).values()
+    );
+    result[key] = { ...table, _data: newData };
+  }
+  return hip(result, { throwOnWrongHashes: false });
+};
+// @license
 const contentTypes = [
   "buffets",
   "cakes",
   "layers",
   "sliceIds",
-  "ingredients"
+  "components",
+  "revisions",
+  "tableCfgs"
 ];
 const exampleTypedefs = () => {
   return {
@@ -684,10 +692,31 @@ const exampleTypedefs = () => {
   };
 };
 // @license
-class BaseValidator {
-  constructor() {
-    __publicField(this, "name", "base");
+const rljsonIndexed = (rljson) => {
+  const result = {};
+  for (const key in rljson) {
+    const slice = rljson[key];
+    if (typeof slice != "object") {
+      result[key] = slice;
+      continue;
+    }
+    const dataIndexed = {};
+    result[key] = { ...slice };
+    if (!Array.isArray(slice._data)) {
+      continue;
+    }
+    for (const row of slice._data) {
+      const hashedRow = row._hash ? row : hsh(row);
+      const hash = hashedRow._hash;
+      dataIndexed[hash] = hashedRow;
+    }
+    result[key]._data = dataIndexed;
   }
+  return result;
+};
+// @license
+class BaseValidator {
+  name = "base";
   async validate(rljson) {
     return this.validateSync(rljson);
   }
@@ -700,18 +729,13 @@ class BaseValidator {
 }
 class _BaseValidator {
   constructor(rljson) {
-    __publicField(this, "errors", { hasErrors: false });
-    // ######################
-    // Private
-    // ######################
-    __publicField(this, "tableKeys");
-    __publicField(this, "rljsonIndexed");
     this.rljson = rljson;
     this.tableKeys = Object.keys(this.rljson).filter(
       (table) => !table.startsWith("_")
     );
     this.rljsonIndexed = rljsonIndexed(rljson);
   }
+  errors = { hasErrors: false };
   get hasErrors() {
     return Object.keys(this.errors).length > 1;
   }
@@ -738,7 +762,7 @@ class _BaseValidator {
       () => this._layerBasesNotFound(),
       () => this._layerSliceIdsTableNotFound(),
       () => this._layerSliceIdsRowNotFound(),
-      () => this._layerIngredientAssignmentsNotFound(),
+      () => this._layerComponentAssignmentsNotFound(),
       () => this._layerAssignmentsDoNotMatchSliceIds(),
       // Check cakes
       () => this._cakeSliceIdsTableNotFound(),
@@ -756,6 +780,11 @@ class _BaseValidator {
     this.errors.hasErrors = this.hasErrors;
     return this.errors;
   }
+  // ######################
+  // Private
+  // ######################
+  tableKeys;
+  rljsonIndexed;
   _tableKeysNotLowerCamelCase() {
     const invalidTableKeys = [];
     for (const tableKey of this.tableKeys) {
@@ -800,7 +829,7 @@ class _BaseValidator {
             continue;
           }
           if (!BaseValidator.isValidFieldName(columnName)) {
-            invalidColumnNames[tableKey] ?? (invalidColumnNames[tableKey] = []);
+            invalidColumnNames[tableKey] ??= [];
             invalidColumnNames[tableKey].push(columnName);
             hadErrors = true;
           }
@@ -1171,7 +1200,6 @@ class _BaseValidator {
       };
     }
   }
-  /* v8 ignore start */
   _layerSliceIdsTableNotFound() {
     const brokenLayers = [];
     iterateTablesSync(this.rljson, (tableKey, table) => {
@@ -1224,8 +1252,8 @@ class _BaseValidator {
       };
     }
   }
-  _layerIngredientAssignmentsNotFound() {
-    const missingIngredientTables = [];
+  _layerComponentAssignmentsNotFound() {
+    const missingComponentTables = [];
     const brokenAssignments = [];
     iterateTablesSync(this.rljson, (tableKey, table) => {
       if (table._type !== "layers") {
@@ -1233,43 +1261,43 @@ class _BaseValidator {
       }
       const layersTable = table;
       for (const layer of layersTable._data) {
-        const ingredientTableKey = layer.ingredientsTable;
-        const ingredientsTable = this.rljsonIndexed[ingredientTableKey];
-        if (!ingredientsTable) {
-          missingIngredientTables.push({
+        const componentTableKey = layer.componentsTable;
+        const componentsTable = this.rljsonIndexed[componentTableKey];
+        if (!componentsTable) {
+          missingComponentTables.push({
             brokenLayer: layer._hash,
             layersTable: tableKey,
-            missingIngredientTable: ingredientTableKey
+            missingComponentTable: componentTableKey
           });
           continue;
         }
-        const assignments = layer.assign;
+        const assignments = layer.add;
         for (const sliceId in assignments) {
           if (sliceId.startsWith("_")) {
             continue;
           }
-          const ingredientHash = assignments[sliceId];
-          if (!ingredientsTable._data[ingredientHash]) {
+          const componentHash = assignments[sliceId];
+          if (!componentsTable._data[componentHash]) {
             brokenAssignments.push({
               layersTable: tableKey,
               brokenLayer: layer._hash,
-              referencedIngredientTable: ingredientTableKey,
+              referencedComponentTable: componentTableKey,
               brokenAssignment: sliceId,
-              missingIngredient: ingredientHash
+              missingComponent: componentHash
             });
           }
         }
       }
     });
-    if (missingIngredientTables.length > 0) {
-      this.errors.layerIngredientTablesNotFound = {
-        error: "Layer ingredient tables do not exist",
-        layers: missingIngredientTables
+    if (missingComponentTables.length > 0) {
+      this.errors.layerComponentTablesNotFound = {
+        error: "Layer component tables do not exist",
+        layers: missingComponentTables
       };
     }
     if (brokenAssignments.length > 0) {
-      this.errors.layerIngredientAssignmentsNotFound = {
-        error: "Layer ingredient assignments are broken",
+      this.errors.layerComponentAssignmentsNotFound = {
+        error: "Layer component assignments are broken",
         brokenAssignments
       };
     }
@@ -1285,7 +1313,7 @@ class _BaseValidator {
         const sliceIdsTable = this.rljsonIndexed[layer.sliceIdsTable];
         const sliceIdsRow = sliceIdsTable._data[layer.sliceIdsTableRow];
         const sliceIds = sliceIdsRow.add;
-        const sliceIdsInLayer = Object.keys(layer.assign);
+        const sliceIdsInLayer = Object.keys(layer.add);
         const unassignedSliceIds = [];
         for (const expectedSliceId of sliceIds) {
           if (sliceIdsInLayer.indexOf(expectedSliceId) === -1) {
@@ -1370,27 +1398,25 @@ class _BaseValidator {
       }
       const cakesTable = table;
       for (const cake of cakesTable._data) {
-        const layersTableKey = cake.layersTable;
-        const layersTable = this.rljsonIndexed[layersTableKey];
-        if (!layersTable) {
-          missingLayerTables.push({
-            cakeTable: tableKey,
-            brokenCake: cake._hash,
-            missingLayersTable: layersTableKey
-          });
-          continue;
-        }
-        for (const layerKey in cake.layers) {
-          if (layerKey.startsWith("_")) {
+        for (const layersTableKey in cake.layers) {
+          if (layersTableKey.startsWith("_")) {
             continue;
           }
-          const layerRef = cake.layers[layerKey];
+          const layersTable = this.rljsonIndexed[layersTableKey];
+          if (!layersTable) {
+            missingLayerTables.push({
+              cakeTable: tableKey,
+              brokenCake: cake._hash,
+              missingLayersTable: layersTableKey
+            });
+            continue;
+          }
+          const layerRef = cake.layers[layersTableKey];
           const layer = layersTable._data[layerRef];
           if (!layer) {
             missingCakeLayers.push({
               cakeTable: tableKey,
               brokenCake: cake._hash,
-              brokenLayerName: layerKey,
               layersTable: layersTableKey,
               missingLayer: layerRef
             });
@@ -1457,17 +1483,10 @@ class _BaseValidator {
       };
     }
   }
-  /* v8 ignore end */
 }
 const isValidFieldName = (fieldName) => BaseValidator.isValidFieldName(fieldName);
 // @license
 class Validate {
-  constructor() {
-    // ######################
-    // Private
-    // ######################
-    __publicField(this, "_validators", []);
-  }
   addValidator(validator) {
     this._validators.push(validator);
   }
@@ -1496,6 +1515,10 @@ class Validate {
       return acc;
     }, {});
   }
+  // ######################
+  // Private
+  // ######################
+  _validators = [];
 }
 export {
   BaseValidator,
@@ -1506,7 +1529,7 @@ export {
   contentTypes,
   exampleBuffetsTable,
   exampleCakesTable,
-  exampleIngredientsTable,
+  exampleComponentsTable,
   exampleLayersTable,
   exampleRevision,
   exampleRljson,
@@ -1517,9 +1540,9 @@ export {
   isValidFieldName,
   iterateTables,
   iterateTablesSync,
+  removeDuplicates,
   reservedFieldNames,
   reservedTableKeys,
-  rljsonIndexed,
   throwOnInvalidTableCfg,
   validateRljsonAgainstTableCfg
 };