@rljson/rljson 0.0.52 → 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/index.d.ts

@@ -8,6 +8,7 @@ export * from './content/table-cfg.ts';
 export * from './example.ts';
 export * from './example/bakery-example.ts';
 export * from './rljson.ts';
+export * from './tools/remove-duplicates.ts';
 export * from './typedefs.ts';
 export * from './validate/base-validator.ts';
 export * from './validate/validate.ts';

package/dist/rljson.js

@@ -291,6 +291,109 @@ __publicField(_Example, "ok", {
       }
     };
   },
+  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" }
+            ]
+          }
+        ]
+      }
+    };
+  },
   complete: () => {
     const sliceIds = hip({
       _type: "sliceIds",
@@ -411,6 +514,53 @@ __publicField(_Example, "broken", {
         }
       };
     },
+    missingNamedRef: () => {
+      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: () => {
+      return {
+        tableA: {
+          _type: "components",
+          _data: [
+            {
+              keyA0: "a0"
+            },
+            {
+              keyA1: "a1"
+            }
+          ]
+        },
+        tableB: {
+          _type: "components",
+          _data: [
+            {
+              tableARef: ["KFQrf4mEz0UPmUaFHwH4T6", "MISSING"]
+            }
+          ]
+        }
+      };
+    },
     missingReferencedTable: () => {
       return {
         tableB: {
@@ -423,6 +573,38 @@ __publicField(_Example, "broken", {
           ]
         }
       };
+    },
+    missingSliceId: () => {
+      return {
+        exampleSliceId: {
+          _type: "sliceIds",
+          _data: [
+            {
+              add: ["id0", "id1"]
+            }
+          ]
+        },
+        exampleComponent: {
+          _type: "components",
+          _data: [
+            {
+              exampleSliceId: "id2"
+            }
+          ]
+        }
+      };
+    },
+    missingSliceIdTable: () => {
+      return {
+        exampleComponent: {
+          _type: "components",
+          _data: [
+            {
+              exampleSliceId: "id0"
+            }
+          ]
+        }
+      };
     }
   },
   tableCfg: {
@@ -664,6 +846,20 @@ 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",
@@ -755,6 +951,7 @@ class _BaseValidator {
       () => this._rootOrHeadTableHasNoIdColumn(),
       // Check references
       () => this._refsNotFound(),
+      () => this._sliceIdRefsNotFound(),
       // Check layers
       () => this._layerBasesNotFound(),
       () => this._layerSliceIdsTableNotFound(),
@@ -1128,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) => {
@@ -1534,6 +1777,7 @@ export {
   isValidFieldName,
   iterateTables,
   iterateTablesSync,
+  removeDuplicates,
   reservedFieldNames,
   reservedTableKeys,
   throwOnInvalidTableCfg,

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/dist/tools/remove-duplicates.d.ts

@@ -0,0 +1,2 @@
+import { Rljson } from '../rljson.ts';
+export declare const removeDuplicates: (rljson: Rljson) => Rljson;

package/package.json

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