@rljson/rljson 0.0.65 → 0.0.67

package/dist/src/example.ts

@@ -16,7 +16,6 @@ import { ColumnCfg, TablesCfgTable } from './content/table-cfg.ts';
 import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
-
 export class Example {
   static readonly ok = {
     bakery: (): Rljson => bakeryExample(),
@@ -158,26 +157,178 @@ export class Example {
     },
 
     singleRef: (): Rljson => {
+      const tableCfgs = hip<TablesCfgTable>({
+        _type: 'tableCfgs',
+        _data: [
+          {
+            key: 'tableA',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyA',
+                type: 'string',
+                titleLong: 'Key',
+                titleShort: 'Key',
+              },
+            ],
+            _hash: '',
+          },
+          {
+            key: 'tableB',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyAFromTableA',
+                type: 'string',
+                titleLong: 'Table A Reference',
+                titleShort: 'TableARef',
+                ref: {
+                  tableKey: 'tableA',
+                  columnKey: 'propertyA',
+                },
+              },
+            ],
+            _hash: '',
+          },
+        ],
+      } as TablesCfgTable);
+
+      const tableA = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[0]._hash as string,
+        _data: [
+          {
+            propertyA: 'a0',
+          },
+          {
+            propertyA: 'a1',
+          },
+        ],
+        _hash: '',
+      });
+
+      const tableB = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[1]._hash as string,
+        _data: [
+          {
+            propertyAFromTableA: tableA._data[0]._hash as string,
+          },
+        ],
+        _hash: '',
+      });
+
       return {
-        tableA: {
-          _type: 'components',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'components',
-          _data: [
-            {
-              tableARef: 'KFQrf4mEz0UPmUaFHwH4T6',
-            },
-          ],
-        },
+        tableCfgs,
+        tableA,
+        tableB,
+      };
+    },
+    multiRef: (): Rljson => {
+      const tableCfgs = hip<TablesCfgTable>({
+        _type: 'tableCfgs',
+        _data: [
+          {
+            key: 'tableA',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyA',
+                type: 'string',
+                titleLong: 'Key',
+                titleShort: 'Key',
+              },
+            ],
+            _hash: '',
+          },
+          {
+            key: 'tableB',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyAFromTableA',
+                type: 'jsonValue',
+                titleLong: 'Table A Reference',
+                titleShort: 'TableARef',
+                ref: {
+                  tableKey: 'tableA',
+                  columnKey: 'propertyA',
+                },
+              },
+            ],
+            _hash: '',
+          },
+        ],
+      } as TablesCfgTable);
+
+      const tableA = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[0]._hash as string,
+        _data: [
+          {
+            propertyA: 'a0',
+          },
+          {
+            propertyA: 'a1',
+          },
+        ],
+        _hash: '',
+      });
+
+      const tableB = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[1]._hash as string,
+        _data: [
+          {
+            propertyAFromTableA: [
+              tableA._data[0]._hash,
+              tableA._data[1]._hash,
+            ] as string[],
+          },
+        ],
+        _hash: '',
+      });
+
+      return {
+        tableCfgs,
+        tableA,
+        tableB,
       };
     },
     singleSliceIdRef: (): Rljson => {
@@ -220,90 +371,6 @@ export class Example {
         } 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',
@@ -413,87 +480,226 @@ export class Example {
       },
 
       missingRef: (): Rljson => {
-        return {
-          tableA: {
-            _type: 'components',
-            _data: [
-              {
-                keyA0: 'a0',
-              },
-              {
-                keyA1: 'a1',
-              },
-            ],
-          },
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: 'MISSINGREF', // MISSINGREF does not exist in tableA
-              },
-            ],
-          },
-        };
-      },
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableA',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyA',
+                  type: 'string',
+                  titleLong: 'Key',
+                  titleShort: 'Key',
+                },
+              ],
+              _hash: '',
+            },
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA',
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableA = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyA: 'a0',
+            },
+            {
+              propertyA: 'a1',
+            },
+          ],
+          _hash: '',
+        });
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[1]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: 'MISSINGREF', // Missing reference
+            },
+          ],
+          _hash: '',
+        });
 
-      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
-              },
-            ],
-          },
+          tableCfgs,
+          tableA,
+          tableB,
         };
       },
 
       missingMultiRef: (): Rljson => {
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableA',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyA',
+                  type: 'string',
+                  titleLong: 'Key',
+                  titleShort: 'Key',
+                },
+              ],
+              _hash: '',
+            },
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA',
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableA = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyA: 'a0',
+            },
+            {
+              propertyA: 'a1',
+            },
+          ],
+          _hash: '',
+        });
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[1]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: [tableA._data[0]._hash, 'MISSINGREF'], // Missing reference
+            },
+          ],
+          _hash: '',
+        });
+
         return {
-          tableA: {
-            _type: 'components',
-            _data: [
-              {
-                keyA0: 'a0',
-              },
-              {
-                keyA1: 'a1',
-              },
-            ],
-          },
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: ['KFQrf4mEz0UPmUaFHwH4T6', 'MISSING'],
-              },
-            ],
-          },
+          tableCfgs,
+          tableA,
+          tableB,
         };
       },
 
       missingReferencedTable: (): Rljson => {
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA', // Referenced table missing
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: 'MISSINGREF', // Missing reference
+            },
+          ],
+          _hash: '',
+        });
+
         return {
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: 'MISSINGREF', // tableA is missing
-              },
-            ],
-          },
+          tableCfgs,
+          tableB,
         };
       },
 

package/dist/typedefs.d.ts

@@ -26,7 +26,7 @@ export type ColumnKey = JsonKey;
  * - `ids` Tables containing slice ids
  * - `components` Tables containing slice components
  */
-export declare const contentTypes: readonly ["buffets", "cakes", "layers", "sliceIds", "components", "revisions", "tableCfgs", "history"];
+export declare const contentTypes: readonly ["buffets", "cakes", "layers", "sliceIds", "components", "revisions", "tableCfgs", "insertHistory"];
 export type ContentType = (typeof contentTypes)[number];
 /**
  * An example object using the typedefs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",
@@ -20,24 +20,24 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@types/node": "^24.9.1",
-    "@typescript-eslint/eslint-plugin": "^8.46.2",
-    "@typescript-eslint/parser": "^8.46.2",
-    "@vitest/coverage-v8": "^4.0.1",
+    "@types/node": "^24.10.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "@vitest/coverage-v8": "^4.0.7",
     "cross-env": "^10.1.0",
-    "eslint": "^9.38.0",
-    "eslint-plugin-jsdoc": "^61.1.5",
+    "eslint": "^9.39.1",
+    "eslint-plugin-jsdoc": "^61.1.12",
     "eslint-plugin-tsdoc": "^0.4.0",
-    "globals": "^16.4.0",
+    "globals": "^16.5.0",
     "jsdoc": "^4.0.5",
     "read-pkg": "^9.0.1",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.46.2",
-    "vite": "^7.1.12",
+    "typescript-eslint": "^8.46.3",
+    "vite": "^7.2.0",
     "vite-node": "^3.2.4",
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.1",
+    "vitest": "^4.0.7",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {

package/dist/history/history.d.ts

@@ -1,24 +0,0 @@
-import { TableCfg } from '../content/table-cfg.ts';
-import { RljsonTable } from '../rljson.ts';
-import { RouteRef } from '../route/route.ts';
-import { Ref } from '../typedefs.ts';
-export type HistoryTimeId = string;
-export type HistoryRow<Str extends string> = {
-    [key in Str as `${Uncapitalize<string & key>}Ref`]: string;
-} & {
-    timeId: HistoryTimeId;
-    route: RouteRef;
-    origin?: Ref;
-    previous?: HistoryTimeId[];
-};
-export type History<Str extends string> = RljsonTable<HistoryRow<Str>, 'history'>;
-/**
- * Creates a TableCfg for a History table for the given table configuration
- * @param tableCfg - The table configuration to create the History table for
- * @returns The TableCfg for the History table
- */
-export declare const createHistoryTableCfg: (tableCfg: TableCfg) => TableCfg;
-/**
- * Provides an example history table for test purposes
- */
-export declare const exampleHistoryTable: () => History<any>;