@rljson/rljson 0.0.53 → 0.0.55

package/dist/example.d.ts

@@ -7,6 +7,10 @@ export declare class Example {
         singleRow: () => Rljson;
         multipleRows: () => Rljson;
         singleRef: () => Rljson;
+        singleSliceIdRef: () => Rljson;
+        singleNamedRef: () => Rljson;
+        multiRef: () => Rljson;
+        multiMixedRef: () => Rljson;
         complete: () => Rljson;
     };
     static readonly broken: {
@@ -19,7 +23,11 @@ export declare class Example {
             missingData: () => Rljson;
             dataNotBeingAnArray: () => Rljson;
             missingRef: () => Rljson;
+            missingNamedRef: () => Rljson;
+            missingMultiRef: () => Rljson;
             missingReferencedTable: () => Rljson;
+            missingSliceId: () => Rljson;
+            missingSliceIdTable: () => Rljson;
         };
         tableCfg: {
             wrongType: () => Rljson;

package/dist/rljson.js

@@ -1,3 +1,6 @@
+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
@@ -154,117 +157,388 @@ const exampleRevision = () => ({
 // @license
 const exampleSliceIdsTable = () => bakeryExample().slices;
 // @license
-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 _Example = class _Example {
+};
+__publicField(_Example, "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 }
+        ]
+      }
+    };
+  },
+  singleRow: () => {
+    const tableCfgs = hip({
+      _hash: "",
+      _type: "tableCfgs",
+      _data: [
+        {
+          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"
+            }
           ]
         }
-      };
-    },
-    singleRow: () => {
-      const tableCfgs = hip({
-        _hash: "",
-        _type: "tableCfgs",
+      ]
+    });
+    const result = {
+      tableCfgs,
+      table: {
+        _tableCfg: tableCfgs._data[0]._hash,
+        _type: "components",
+        _data: [exampleJsonObject()],
+        _hash: ""
+      }
+    };
+    return result;
+  },
+  multipleRows: () => {
+    return {
+      table: {
+        _type: "components",
         _data: [
           {
-            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"
-              }
+            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: {
+        _type: "components",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "components",
+        _data: [
+          {
+            tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
+          }
+        ]
+      }
+    };
+  },
+  singleSliceIdRef: () => {
+    return {
+      exampleSliceId: {
+        _type: "sliceIds",
+        _data: [
+          {
+            add: ["id0", "id1"]
+          }
+        ]
+      },
+      exampleComponent: {
+        _type: "components",
+        _data: [
+          {
+            exampleSliceId: "id0"
+          }
+        ]
+      }
+    };
+  },
+  singleNamedRef: () => {
+    return {
+      tableA: {
+        _type: "components",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "components",
+        _data: [
+          {
+            namedRef: { component: "tableA", ref: "KFQrf4mEz0UPmUaFHwH4T6" }
+          }
+        ]
+      }
+    };
+  },
+  multiRef: () => {
+    return {
+      tableA: {
+        _type: "components",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "components",
+        _data: [
+          {
+            tableARef: ["KFQrf4mEz0UPmUaFHwH4T6", "YPw-pxhqaUOWRFGramr4B1"]
+          }
+        ]
+      }
+    };
+  },
+  multiMixedRef: () => {
+    return {
+      tableA: {
+        _type: "components",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "components",
+        _data: [
+          {
+            keyB0: "b0"
+          },
+          {
+            keyB1: "b1"
+          }
+        ]
+      },
+      tableC: {
+        _type: "components",
+        _data: [
+          {
+            tableRef: [
+              { component: "tableA", ref: "KFQrf4mEz0UPmUaFHwH4T6" },
+              { component: "tableB", ref: "dXhIygNwNMVPEqFbsFJkn6" }
             ]
           }
         ]
-      });
-      const result = {
-        tableCfgs,
-        table: {
-          _tableCfg: tableCfgs._data[0]._hash,
-          _type: "components",
-          _data: [exampleJsonObject()],
-          _hash: ""
+      }
+    };
+  },
+  complete: () => {
+    const sliceIds = hip({
+      _type: "sliceIds",
+      _data: [
+        {
+          add: ["id0", "id1"]
+        }
+      ]
+    });
+    const components = hip({
+      _type: "components",
+      _data: [{ a: "0" }, { a: "1" }]
+    });
+    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
+      }
+    });
+    const abLayer1 = hip({
+      base: abLayer0._hash,
+      sliceIdsTable: "sliceIds",
+      sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
+      componentsTable: "components",
+      add: {
+        id0: component0._hash,
+        id1: component1._hash
+      }
+    });
+    const abLayers = hip({
+      _type: "layers",
+      _data: [abLayer0, abLayer1]
+    });
+    const cake = hip({
+      sliceIdsTable: "sliceIds",
+      sliceIdsRow: sliceIds._data[0]._hash,
+      layers: {
+        abLayers: abLayer1._hash
+      }
+    });
+    const cakes = hip({
+      _type: "cakes",
+      _data: [cake]
+    });
+    const buffets = hip({
+      _type: "buffets",
+      _data: [
+        {
+          items: [
+            {
+              table: "cakes",
+              ref: cakes._data[0]._hash
+            },
+            {
+              table: "abLayers",
+              ref: abLayer0._hash
+            }
+          ]
+        }
+      ]
+    });
+    return {
+      sliceIds,
+      components,
+      abLayers,
+      cakes,
+      buffets
+    };
+  }
+});
+__publicField(_Example, "broken", {
+  base: {
+    brokenTableKey: () => {
+      return {
+        brok$en: {
+          _data: []
         }
       };
-      return result;
     },
-    multipleRows: () => {
+    missingData: () => {
+      return {
+        table: {}
+      };
+    },
+    dataNotBeingAnArray: () => {
       return {
         table: {
+          _data: {}
+        }
+      };
+    },
+    missingRef: () => {
+      return {
+        tableA: {
           _type: "components",
           _data: [
             {
-              string: "str0",
-              boolean: true,
-              number: 1,
-              array: [1, "str0", true, { a: { b: "c" } }],
-              object: { a: { b: "c" } }
+              keyA0: "a0"
             },
             {
-              string: "str1",
-              boolean: true,
-              number: 1,
-              array: [1, "str1", true, { a: { b: "c" } }],
-              object: { a: { b: "c" } }
+              keyA1: "a1"
+            }
+          ]
+        },
+        tableB: {
+          _type: "components",
+          _data: [
+            {
+              tableARef: "MISSINGREF"
+              // MISSINGREF does not exist in tableA
+            }
+          ]
+        }
+      };
+    },
+    missingNamedRef: () => {
+      return {
+        tableA: {
+          _type: "components",
+          _data: [
+            {
+              keyA0: "a0"
             },
             {
-              string: "str2",
-              boolean: false,
-              number: 1,
-              array: [1, "str1", true, { a: { b: "c" } }],
-              object: { d: { e: "f" } }
+              keyA1: "a1"
+            }
+          ]
+        },
+        tableB: {
+          _type: "components",
+          _data: [
+            {
+              namedRef: { component: "tableA", ref: "MISSINGREF" }
+              // MISSINGREF does not exist in tableA
             }
           ]
         }
       };
     },
-    singleRef: () => {
+    missingMultiRef: () => {
       return {
         tableA: {
           _type: "components",
@@ -281,245 +555,157 @@ class Example {
           _type: "components",
           _data: [
             {
-              tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
+              tableARef: ["KFQrf4mEz0UPmUaFHwH4T6", "MISSING"]
             }
           ]
         }
       };
     },
-    complete: () => {
-      const sliceIds = hip({
-        _type: "sliceIds",
-        _data: [
-          {
-            add: ["id0", "id1"]
-          }
-        ]
-      });
-      const components = hip({
-        _type: "components",
-        _data: [{ a: "0" }, { a: "1" }]
-      });
-      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
+    missingReferencedTable: () => {
+      return {
+        tableB: {
+          _type: "components",
+          _data: [
+            {
+              tableARef: "MISSINGREF"
+              // tableA is missing
+            }
+          ]
         }
-      });
-      const abLayer1 = hip({
-        base: abLayer0._hash,
-        sliceIdsTable: "sliceIds",
-        sliceIdsTableRow: "MgHRBYSrhpyl4rvsOmAWcQ",
-        componentsTable: "components",
-        add: {
-          id0: component0._hash,
-          id1: component1._hash
+      };
+    },
+    missingSliceId: () => {
+      return {
+        exampleSliceId: {
+          _type: "sliceIds",
+          _data: [
+            {
+              add: ["id0", "id1"]
+            }
+          ]
+        },
+        exampleComponent: {
+          _type: "components",
+          _data: [
+            {
+              exampleSliceId: "id2"
+            }
+          ]
         }
-      });
-      const abLayers = hip({
-        _type: "layers",
-        _data: [abLayer0, abLayer1]
-      });
-      const cake = hip({
-        sliceIdsTable: "sliceIds",
-        sliceIdsRow: sliceIds._data[0]._hash,
-        layers: {
-          abLayers: abLayer1._hash
+      };
+    },
+    missingSliceIdTable: () => {
+      return {
+        exampleComponent: {
+          _type: "components",
+          _data: [
+            {
+              exampleSliceId: "id0"
+            }
+          ]
         }
+      };
+    }
+  },
+  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
       });
-      const cakes = hip({
-        _type: "cakes",
-        _data: [cake]
+    }
+  },
+  layers: {
+    missingBase: () => {
+      const result = _Example.ok.complete();
+      const layer1 = result.abLayers._data[1];
+      layer1.base = "MISSING";
+      return hip(result, {
+        updateExistingHashes: true,
+        throwOnWrongHashes: false
       });
-      const buffets = hip({
-        _type: "buffets",
-        _data: [
-          {
-            items: [
-              {
-                table: "cakes",
-                ref: cakes._data[0]._hash
-              },
-              {
-                table: "abLayers",
-                ref: abLayer0._hash
-              }
-            ]
-          }
-        ]
+    },
+    missingSliceIdSet: () => {
+      const result = _Example.ok.complete();
+      const layer1 = result.abLayers._data[1];
+      layer1.sliceIdsTableRow = "MISSING1";
+      return hip(result, {
+        updateExistingHashes: true,
+        throwOnWrongHashes: false
       });
-      return {
-        sliceIds,
-        components,
-        abLayers,
-        cakes,
-        buffets
-      };
-    }
-  };
-  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
-              }
-            ]
-          }
-        };
-      }
     },
-    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
-        });
-      }
+    missingAssignedComponentTable: () => {
+      const result = _Example.ok.complete();
+      delete result.components;
+      return result;
     },
-    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
-        });
-      }
+    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;
     },
-    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;
-      }
+    missingLayersTable: () => {
+      const result = _Example.ok.complete();
+      result.cakes._data[0].layers = { MISSING: "HASH" };
+      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;
-      }
+    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) {
@@ -598,8 +784,8 @@ const addColumnsToTableCfg = (tableCfg, columns) => {
 const exampleTableCfgTable = () => Example.ok.singleRow().tableCfgs;
 const exampleTableCfg = (tableCfg = void 0) => {
   return {
-    key: tableCfg?.key ?? "table",
-    columns: tableCfg?.columns ?? [
+    key: (tableCfg == null ? void 0 : tableCfg.key) ?? "table",
+    columns: (tableCfg == null ? void 0 : tableCfg.columns) ?? [
       {
         key: "_hash",
         type: "string"
@@ -613,7 +799,7 @@ const exampleTableCfg = (tableCfg = void 0) => {
         type: "number"
       }
     ],
-    type: tableCfg?.type ?? "components",
+    type: (tableCfg == null ? void 0 : tableCfg.type) ?? "components",
     isHead: true,
     isRoot: true,
     isShared: false
@@ -716,7 +902,9 @@ const rljsonIndexed = (rljson) => {
 };
 // @license
 class BaseValidator {
-  name = "base";
+  constructor() {
+    __publicField(this, "name", "base");
+  }
   async validate(rljson) {
     return this.validateSync(rljson);
   }
@@ -729,13 +917,18 @@ 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;
   }
@@ -758,6 +951,7 @@ class _BaseValidator {
       () => this._rootOrHeadTableHasNoIdColumn(),
       // Check references
       () => this._refsNotFound(),
+      () => this._sliceIdRefsNotFound(),
       // Check layers
       () => this._layerBasesNotFound(),
       () => this._layerSliceIdsTableNotFound(),
@@ -780,11 +974,6 @@ class _BaseValidator {
     this.errors.hasErrors = this.hasErrors;
     return this.errors;
   }
-  // ######################
-  // Private
-  // ######################
-  tableKeys;
-  rljsonIndexed;
   _tableKeysNotLowerCamelCase() {
     const invalidTableKeys = [];
     for (const tableKey of this.tableKeys) {
@@ -829,7 +1018,7 @@ class _BaseValidator {
             continue;
           }
           if (!BaseValidator.isValidFieldName(columnName)) {
-            invalidColumnNames[tableKey] ??= [];
+            invalidColumnNames[tableKey] ?? (invalidColumnNames[tableKey] = []);
             invalidColumnNames[tableKey].push(columnName);
             hadErrors = true;
           }
@@ -1136,43 +1325,89 @@ class _BaseValidator {
       for (const item of tableData) {
         for (const key of Object.keys(item)) {
           if (key.endsWith("Ref")) {
-            const targetItemHash = item[key];
-            const targetTableKey = key.substring(0, key.length - 3);
-            const itemHash = item._hash;
-            if (this.tableKeys.indexOf(targetTableKey) === -1) {
-              missingRefs.push({
-                error: `Target table "${targetTableKey}" not found.`,
+            const targetItemRefs = Array.isArray(item[key]) ? item[key] : [item[key]];
+            for (const targetItemRef of targetItemRefs) {
+              const targetTableKey = typeof targetItemRef !== "string" ? targetItemRef.component : key.substring(0, key.length - 3);
+              const targetItemHash = typeof targetItemRef !== "string" ? targetItemRef.ref : targetItemRef;
+              const itemHash = item._hash;
+              if (this.tableKeys.indexOf(targetTableKey) === -1) {
+                missingRefs.push({
+                  error: `Target table "${targetTableKey}" not found.`,
+                  sourceTable: tableKey,
+                  sourceKey: key,
+                  sourceItemHash: itemHash,
+                  targetItemHash,
+                  targetTable: targetTableKey
+                });
+                continue;
+              }
+              const targetTableIndexed = this.rljsonIndexed[targetTableKey];
+              const referencedItem = targetTableIndexed._data[targetItemHash];
+              if (referencedItem === void 0) {
+                missingRefs.push({
+                  sourceTable: tableKey,
+                  sourceItemHash: itemHash,
+                  sourceKey: key,
+                  targetItemHash,
+                  targetTable: targetTableKey,
+                  error: `Table "${targetTableKey}" has no item with hash "${targetItemHash}"`
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+    if (missingRefs.length > 0) {
+      this.errors.refsNotFound = {
+        error: "Broken references",
+        missingRefs
+      };
+    }
+  }
+  // ...........................................................................
+  _sliceIdRefsNotFound() {
+    const missingSliceIdRefs = [];
+    iterateTablesSync(this.rljson, (tableKey, table) => {
+      const tableData = table._data;
+      for (const item of tableData) {
+        for (const key of Object.keys(item)) {
+          if (key.endsWith("SliceId")) {
+            const targetSliceId = item[key];
+            if (this.tableKeys.indexOf(key) === -1) {
+              missingSliceIdRefs.push({
                 sourceTable: tableKey,
-                sourceKey: key,
-                sourceItemHash: itemHash,
-                targetItemHash,
-                targetTable: targetTableKey
+                targetSliceId,
+                targetTable: key,
+                error: `Target table "${targetSliceId}" not found.`
               });
               continue;
             }
-            const targetTableIndexed = this.rljsonIndexed[targetTableKey];
-            const referencedItem = targetTableIndexed._data[targetItemHash];
-            if (referencedItem === void 0) {
-              missingRefs.push({
+            const targetSliceIdsTable = this.rljson[key];
+            const targetSliceIds = targetSliceIdsTable._data.flatMap((d) => [
+              ...d.add,
+              ...d.remove ?? []
+            ]);
+            if (targetSliceIds.indexOf(targetSliceId) === -1) {
+              missingSliceIdRefs.push({
                 sourceTable: tableKey,
-                sourceItemHash: itemHash,
-                sourceKey: key,
-                targetItemHash,
-                targetTable: targetTableKey,
-                error: `Table "${targetTableKey}" has no item with hash "${targetItemHash}"`
+                targetSliceId,
+                targetTable: key,
+                error: `Table "${key}" has no sliceId "${targetSliceId}"`
               });
             }
           }
         }
       }
     });
-    if (missingRefs.length > 0) {
+    if (missingSliceIdRefs.length > 0) {
       this.errors.refsNotFound = {
         error: "Broken references",
-        missingRefs
+        missingRefs: missingSliceIdRefs
       };
     }
   }
+  // ...........................................................................
   _layerBasesNotFound() {
     const brokenLayers = [];
     iterateTablesSync(this.rljson, (tableKey, table) => {
@@ -1487,6 +1722,12 @@ class _BaseValidator {
 const isValidFieldName = (fieldName) => BaseValidator.isValidFieldName(fieldName);
 // @license
 class Validate {
+  constructor() {
+    // ######################
+    // Private
+    // ######################
+    __publicField(this, "_validators", []);
+  }
   addValidator(validator) {
     this._validators.push(validator);
   }
@@ -1515,10 +1756,6 @@ class Validate {
       return acc;
     }, {});
   }
-  // ######################
-  // Private
-  // ######################
-  _validators = [];
 }
 export {
   BaseValidator,

package/dist/src/example.ts

@@ -5,7 +5,7 @@
 // found in the LICENSE file in the root of this package.
 
 import { hip } from '@rljson/hash';
-import { exampleJsonObject } from '@rljson/json';
+import { exampleJsonObject, Json } from '@rljson/json';
 
 import { BuffetsTable } from './content/buffet.ts';
 import { Cake, CakesTable } from './content/cake.ts';
@@ -157,6 +157,110 @@ export class Example {
         },
       };
     },
+    singleSliceIdRef: (): Rljson => {
+      return {
+        exampleSliceId: {
+          _type: 'sliceIds',
+          _data: [
+            {
+              add: ['id0', 'id1'],
+            },
+          ],
+        } as SliceIdsTable,
+        exampleComponent: {
+          _type: 'components',
+          _data: [
+            {
+              exampleSliceId: 'id0',
+            },
+          ],
+        } as ComponentsTable<Json>,
+      };
+    },
+    singleNamedRef: (): Rljson => {
+      return {
+        tableA: {
+          _type: 'components',
+          _data: [
+            {
+              keyA0: 'a0',
+            },
+            {
+              keyA1: 'a1',
+            },
+          ],
+        },
+        tableB: {
+          _type: 'components',
+          _data: [
+            {
+              namedRef: { component: 'tableA', ref: 'KFQrf4mEz0UPmUaFHwH4T6' },
+            },
+          ],
+        },
+      };
+    },
+    multiRef: (): Rljson => {
+      return {
+        tableA: {
+          _type: 'components',
+          _data: [
+            {
+              keyA0: 'a0',
+            },
+            {
+              keyA1: 'a1',
+            },
+          ],
+        },
+        tableB: {
+          _type: 'components',
+          _data: [
+            {
+              tableARef: ['KFQrf4mEz0UPmUaFHwH4T6', 'YPw-pxhqaUOWRFGramr4B1'],
+            },
+          ],
+        },
+      };
+    },
+    multiMixedRef: (): Rljson => {
+      return {
+        tableA: {
+          _type: 'components',
+          _data: [
+            {
+              keyA0: 'a0',
+            },
+            {
+              keyA1: 'a1',
+            },
+          ],
+        },
+        tableB: {
+          _type: 'components',
+          _data: [
+            {
+              keyB0: 'b0',
+            },
+            {
+              keyB1: 'b1',
+            },
+          ],
+        },
+        tableC: {
+          _type: 'components',
+          _data: [
+            {
+              tableRef: [
+                { component: 'tableA', ref: 'KFQrf4mEz0UPmUaFHwH4T6' },
+                { component: 'tableB', ref: 'dXhIygNwNMVPEqFbsFJkn6' },
+              ],
+            },
+          ],
+        },
+      };
+    },
+
     complete: (): Rljson => {
       const sliceIds = hip<SliceIdsTable>({
         _type: 'sliceIds',
@@ -289,6 +393,54 @@ export class Example {
         };
       },
 
+      missingNamedRef: (): Rljson => {
+        return {
+          tableA: {
+            _type: 'components',
+            _data: [
+              {
+                keyA0: 'a0',
+              },
+              {
+                keyA1: 'a1',
+              },
+            ],
+          },
+          tableB: {
+            _type: 'components',
+            _data: [
+              {
+                namedRef: { component: 'tableA', ref: 'MISSINGREF' }, // MISSINGREF does not exist in tableA
+              },
+            ],
+          },
+        };
+      },
+
+      missingMultiRef: (): Rljson => {
+        return {
+          tableA: {
+            _type: 'components',
+            _data: [
+              {
+                keyA0: 'a0',
+              },
+              {
+                keyA1: 'a1',
+              },
+            ],
+          },
+          tableB: {
+            _type: 'components',
+            _data: [
+              {
+                tableARef: ['KFQrf4mEz0UPmUaFHwH4T6', 'MISSING'],
+              },
+            ],
+          },
+        };
+      },
+
       missingReferencedTable: (): Rljson => {
         return {
           tableB: {
@@ -301,6 +453,40 @@ export class Example {
           },
         };
       },
+
+      missingSliceId: (): Rljson => {
+        return {
+          exampleSliceId: {
+            _type: 'sliceIds',
+            _data: [
+              {
+                add: ['id0', 'id1'],
+              },
+            ],
+          } as SliceIdsTable,
+          exampleComponent: {
+            _type: 'components',
+            _data: [
+              {
+                exampleSliceId: 'id2',
+              },
+            ],
+          } as ComponentsTable<Json>,
+        };
+      },
+
+      missingSliceIdTable: (): Rljson => {
+        return {
+          exampleComponent: {
+            _type: 'components',
+            _data: [
+              {
+                exampleSliceId: 'id0',
+              },
+            ],
+          } as ComponentsTable<Json>,
+        };
+      },
     },
 
     tableCfg: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",