@rljson/rljson 0.0.61 → 0.0.64

package/dist/content/cake.d.ts

@@ -43,7 +43,7 @@ export type CakesTable = RljsonTable<Cake, 'cakes'>;
 /**
  * Sample Table as BoilerPlate for Tests and Examples
  */
-/**
+/**pnpm build
  * Sample Table as BoilerPlate for Tests and Examples
  * @param cakeKey - the key of the cake table cfg
  */

package/dist/content/table-cfg.d.ts

@@ -17,6 +17,23 @@ export interface ColumnCfg extends Json {
      * The type of the column
      */
     type: JsonValueType;
+    /**
+     * An optional long title of the column
+     */
+    titleLong: string;
+    /**
+     * An optional short title of the column
+     */
+    titleShort: string;
+}
+/**
+ * A column configuration with route
+ */
+export interface ColumnCfgWithRoute extends ColumnCfg {
+    /**
+     * An optional route for reference columns
+     */
+    route: string;
 }
 /**
  * Describes the configuration of a table, i.e. table metadata and columns

package/dist/edit/history.d.ts

@@ -0,0 +1,24 @@
+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>;

package/dist/edit/insert-validator.d.ts

@@ -0,0 +1,47 @@
+import { Json } from '@rljson/json';
+import { Errors } from '../validate/validate.ts';
+import { Insert } from './insert.ts';
+export interface InsertErrors extends Errors {
+    invalidObject?: Json;
+    parameterInvalid?: Json;
+    parameterRouteInvalid?: Json;
+    parameterCommandInvalid?: Json;
+    parameterValueInvalid?: Json;
+    parameterOriginInvalid?: Json;
+    parameterPreviousInvalid?: Json;
+    routeInvalid?: Json;
+    dataRouteMismatch?: Json;
+}
+export declare class InsertValidator<T extends Json> {
+    private _insert;
+    errors: InsertErrors;
+    /**
+     * Indicates whether there are any errors
+     * @returns boolean - True if there are errors, false otherwise
+     */
+    get hasErrors(): boolean;
+    constructor(_insert: Insert<T>);
+    /**
+     * Validates the Insert object
+     * @returns InsertErrors - The errors found during validation
+     */
+    validate(): InsertErrors;
+    /**
+     * Recursively checks that all reference keys in the value match the route segments
+     * @param route - The current route segment
+     * @param value - The current value object
+     */
+    private _checkMatchingRefs;
+    /**
+     * Creates an InsertValidator for the given Insert object
+     * @param insert - The Insert object to validate
+     * @returns InsertValidator - The InsertValidator instance
+     */
+    static create(insert: Insert<any>): InsertValidator<any>;
+}
+/**
+ * Validates the given Insert object
+ * @param insert - The Insert object to validate
+ * @returns InsertErrors - The errors found during validation
+ */
+export declare const validateInsert: (insert: Insert<any>) => InsertErrors;

package/dist/edit/insert.d.ts

@@ -0,0 +1,19 @@
+import { Json } from '@rljson/json';
+import { RouteRef } from '../route/route.ts';
+import { Ref } from '../typedefs.ts';
+/**
+ * An Insert Object describing inserts on data basically
+ */
+export type InsertRef = Ref;
+export type InsertCommand = 'add' | 'remove';
+/**
+ * An Insert describes a change to be applied to an Rljson object.
+ * @param T - The type of the value being edited, extending Json
+ */
+export type Insert<T extends Json> = {
+    command: InsertCommand;
+    value: T;
+    route: RouteRef;
+    origin?: Ref;
+    acknowledged?: boolean;
+};

package/dist/example/bakery-example.d.ts

@@ -4,7 +4,7 @@ import { CakesTable } from '../content/cake.ts';
 import { ComponentsTable } from '../content/components.ts';
 import { LayersTable } from '../content/layer.ts';
 import { SliceIdsTable } from '../content/slice-ids.ts';
-import { EditProtocol } from '../edit/edit.ts';
+import { History } from '../edit/history.ts';
 import { Rljson } from '../rljson.ts';
 import { Ref } from '../typedefs.ts';
 export interface Ingredient extends Json {
@@ -32,6 +32,6 @@ export interface Bakery extends Rljson {
     recipeIngredients: ComponentsTable<RecipIngredient>;
     ingredients: ComponentsTable<Ingredient>;
     nutritionalValues: ComponentsTable<NutritionalValues>;
-    ingredientsEdits: EditProtocol<'Ingredients'>;
+    ingredientsHistory: History<'Ingredients'>;
 }
 export declare const bakeryExample: () => Bakery;

package/dist/index.d.ts

@@ -5,11 +5,13 @@ export * from './content/layer.ts';
 export * from './content/revision.ts';
 export * from './content/slice-ids.ts';
 export * from './content/table-cfg.ts';
-export * from './edit/edit.ts';
-export * from './edit/route.ts';
+export * from './edit/history.ts';
+export * from './edit/insert-validator.ts';
+export * from './edit/insert.ts';
 export * from './example.ts';
 export * from './example/bakery-example.ts';
 export * from './rljson.ts';
+export * from './route/route.ts';
 export * from './tools/remove-duplicates.ts';
 export * from './tools/time-id.ts';
 export * from './typedefs.ts';

package/dist/rljson.d.ts

@@ -6,14 +6,14 @@ import { LayersTable } from './content/layer.ts';
 import { RevisionsTable } from './content/revision.ts';
 import { SliceIdsTable } from './content/slice-ids.ts';
 import { TableCfgRef, TablesCfgTable } from './content/table-cfg.ts';
-import { EditProtocol } from './edit/edit.ts';
+import { History } from './edit/history.ts';
 import { ContentType, Ref, TableKey } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
 export declare const reservedTableKeys: string[];
 /**
  * One of the supported Rljson table types
  */
-export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | EditProtocol<any>;
+export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | History<any>;
 /** The rljson data format */
 export interface Rljson extends Json {
     [tableId: TableKey]: TableType;

package/dist/rljson.js

@@ -3,36 +3,166 @@ import { exampleJsonObject, jsonValueTypes, jsonValueMatchesType, jsonValueType
 import { nanoid } from "nanoid";
 // @license
 class Route {
-  constructor(segments) {
-    this.segments = segments;
+  constructor(_segments) {
+    this._segments = _segments;
   }
+  // .............................................................................
+  /**
+   * Creates a Route from a flat string representation.
+   * @param route - The flat string representation of the route (e.g. "/a/b/c")
+   * @returns A Route object
+   */
   static fromFlat(route) {
-    return new Route(route.split("/").filter(Boolean));
+    const segmentsFlat = route.split("/").filter((s) => s.length > 0);
+    const segments = [];
+    for (const segmentFlat of segmentsFlat) {
+      const [tableKey, refFlat] = segmentFlat.split("@");
+      const ref = !!refFlat ? refFlat.split(":").length == 2 ? { [tableKey + "HistoryRef"]: refFlat } : { [tableKey + "Ref"]: refFlat } : {};
+      const segment = {
+        tableKey,
+        ...ref
+      };
+      segments.push(segment);
+    }
+    return new Route(segments);
   }
+  // .............................................................................
+  /**
+   * Returns the segment at the given index or the last segment if no index is provided.
+   * @param index - The index of the segment to return (optional)
+   * @returns The segment at the given index or the last segment
+   */
   segment(index) {
     if (index === void 0) {
-      return this.segments[this.segments.length - 1];
+      return this._segments[this._segments.length - 1];
     }
-    return this.segments[index];
+    return this._segments[index];
   }
+  // .............................................................................
+  /**
+   * Returns a new Route that is one level deeper than the current route.
+   * If steps is provided, it returns a new Route that is 'steps' levels deeper.
+   * @param steps - The number of levels to go deeper (optional)
+   * @returns A new Route that is one level deeper or 'steps' levels deeper
+   */
   deeper(steps) {
     if (steps === void 0) {
-      return new Route(this.segments.slice(1, this.segments.length));
+      return new Route(this._segments.slice(1, this._segments.length));
     } else {
       if (steps < 1) {
         throw new Error("Steps must be greater than 0");
       }
-      if (steps >= this.segments.length) {
+      if (steps >= this._segments.length) {
         throw new Error("Cannot go deeper than the root");
       }
-      return new Route(this.segments.slice(steps, this.segments.length));
+      return new Route(this._segments.slice(steps, this._segments.length));
     }
   }
+  // .............................................................................
+  /**
+   * Checks if the current route is the root route.
+   * @returns True if the current route is the root route, false otherwise
+   */
   get isRoot() {
-    return this.segments.length === 1;
+    return this._segments.length === 1;
   }
+  // .............................................................................
+  /**
+   * Returns the flat string representation of the route.
+   * @returns The flat string representation of the route (e.g. "/a/b/c")
+   */
   get flat() {
-    return "/" + this.segments.join("/");
+    let flat = "";
+    for (const segment of this._segments) {
+      const tableKey = segment.tableKey;
+      const ref = Object.keys(segment).filter((k) => k !== "tableKey")[0];
+      flat += `/${tableKey}${ref ? `@${segment[ref]}` : ""}`;
+    }
+    return flat;
+  }
+  // .............................................................................
+  /**
+   * Returns the segments of the route as an array of strings.
+   * @returns The segments of the route as an array of strings
+   */
+  get segments() {
+    return this._segments;
+  }
+  // .............................................................................
+  /**
+   * Returns the root segment of the route.
+   * @returns The root segment of the route
+   */
+  get root() {
+    return this.segment();
+  }
+  // .............................................................................
+  /**
+   * Returns the top level segment of the route.
+   * @returns The top level segment of the route
+   */
+  get top() {
+    return this.segment(0);
+  }
+  // .............................................................................
+  /**
+   * Returns the next segment of the route if it exists.
+   * @returns The next segment of the route or undefined if it doesn't exist
+   */
+  get next() {
+    return this._segments.length > 1 ? this._segments[1] : void 0;
+  }
+  // .............................................................................
+  /**
+   * Checks if the route is valid (i.e. has at least one segment and no empty segments).
+   * @returns True if the route is valid, false otherwise
+   */
+  get isValid() {
+    return this._segments.length > 0 && this._segments.every((s) => s.tableKey.length > 0);
+  }
+  // .............................................................................
+  /**
+   * Returns the reference of a segment if it exists.
+   * @param segment - The segment to get the reference from
+   * @returns The reference of the segment or undefined if it doesn't exist
+   */
+  static segmentRef(segment) {
+    if (this.segmentHasRef(segment)) {
+      const refKey = Object.keys(segment).find(
+        (k) => k.endsWith("Ref") && k !== "tableKey"
+      );
+      if (refKey) {
+        return segment[refKey];
+      }
+    }
+    return void 0;
+  }
+  // .............................................................................
+  /**
+   * Checks if a segment has any reference (either default or history).
+   * @param segment - The segment to check
+   * @returns True if the segment has any reference, false otherwise
+   */
+  static segmentHasRef(segment) {
+    return Object.keys(segment).some((k) => k.endsWith("Ref"));
+  }
+  // .............................................................................
+  /**
+   * Checks if a segment has a default reference (i.e. not a history reference).
+   * @param segment - The segment to check
+   * @returns True if the segment has a default reference, false otherwise
+   */
+  static segmentHasDefaultRef(segment) {
+    return this.segmentHasRef(segment) && !this.segmentHasHistoryRef(segment);
+  }
+  // .............................................................................
+  /**
+   * Checks if a segment has a history reference (i.e. an HistoryRef).
+   * @param segment - The segment to check
+   * @returns True if the segment has a history reference, false otherwise
+   */
+  static segmentHasHistoryRef(segment) {
+    return this.segmentHasRef(segment) && Object.keys(segment).some((k) => k.endsWith("HistoryRef"));
   }
 }
 // @license
@@ -163,8 +293,8 @@ const bakeryExample = () => {
       }
     ]
   });
-  const ingredientsEdits = hip({
-    _type: "edits",
+  const ingredientsHistory = hip({
+    _type: "history",
     _data: [
       {
         timeId: "de72:1759123957292",
@@ -193,7 +323,7 @@ const bakeryExample = () => {
     recipeIngredients,
     ingredients,
     nutritionalValues,
-    ingredientsEdits
+    ingredientsHistory
   };
   return result;
 };
@@ -204,10 +334,21 @@ const createCakeTableCfg = (cakeKey) => ({
   key: cakeKey,
   type: "cakes",
   columns: [
-    { key: "sliceIdsTable", type: "string" },
-    { key: "sliceIdsRow", type: "string" },
-    { key: "layers", type: "jsonArray" },
-    { key: "id", type: "string" }
+    { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+    {
+      key: "sliceIdsTable",
+      type: "string",
+      titleLong: "Slice Ids Table",
+      titleShort: "Slice Ids Table"
+    },
+    {
+      key: "sliceIdsRow",
+      type: "string",
+      titleLong: "Slice Ids Row",
+      titleShort: "Slice Ids Row"
+    },
+    { key: "layers", type: "json", titleLong: "Layers", titleShort: "Layers" },
+    { key: "id", type: "string", titleLong: "ID", titleShort: "ID" }
   ],
   isHead: false,
   isRoot: false,
@@ -221,12 +362,28 @@ const createLayerTableCfg = (layerKey) => ({
   key: layerKey,
   type: "layers",
   columns: [
-    { key: "base", type: "string" },
-    { key: "sliceIdsTable", type: "string" },
-    { key: "sliceIdsTableRow", type: "string" },
-    { key: "componentsTable", type: "string" },
-    { key: "add", type: "jsonArray" },
-    { key: "remove", type: "jsonArray" }
+    { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+    { key: "base", type: "string", titleLong: "Base", titleShort: "Base" },
+    {
+      key: "sliceIdsTable",
+      type: "string",
+      titleLong: "Slice Ids Table",
+      titleShort: "Slice Ids Table"
+    },
+    {
+      key: "sliceIdsTableRow",
+      type: "string",
+      titleLong: "Slice Ids Table Row",
+      titleShort: "Slice Ids Table Row"
+    },
+    {
+      key: "componentsTable",
+      type: "string",
+      titleLong: "Components Table",
+      titleShort: "Components Table"
+    },
+    { key: "add", type: "json", titleLong: "Add", titleShort: "Add" },
+    { key: "remove", type: "json", titleLong: "Remove", titleShort: "Remove" }
   ],
   isHead: false,
   isRoot: false,
@@ -279,39 +436,57 @@ class Example {
             columns: [
               {
                 key: "_hash",
-                type: "string"
+                type: "string",
+                titleLong: "Hash",
+                titleShort: "Hash"
               },
               {
                 key: "int",
-                type: "number"
+                type: "number",
+                titleLong: "Integer",
+                titleShort: "Int"
               },
               {
                 key: "double",
-                type: "number"
+                type: "number",
+                titleLong: "Double",
+                titleShort: "Double"
               },
               {
                 key: "string",
-                type: "string"
+                type: "string",
+                titleLong: "String",
+                titleShort: "String"
               },
               {
                 key: "boolean",
-                type: "boolean"
+                type: "boolean",
+                titleLong: "Boolean",
+                titleShort: "Boolean"
               },
               {
                 key: "null",
-                type: "string"
+                type: "string",
+                titleLong: "Null",
+                titleShort: "Null"
               },
               {
                 key: "jsonArray",
-                type: "jsonArray"
+                type: "jsonArray",
+                titleLong: "JSON Array",
+                titleShort: "JSONArray"
               },
               {
                 key: "json",
-                type: "json"
+                type: "json",
+                titleLong: "JSON Object",
+                titleShort: "JSONObject"
               },
               {
                 key: "jsonValue",
-                type: "jsonValue"
+                type: "jsonValue",
+                titleLong: "JSON Value",
+                titleShort: "JSONValue"
               }
             ]
           }
@@ -900,14 +1075,20 @@ const exampleTableCfg = (tableCfg = void 0) => {
     columns: tableCfg?.columns ?? [
       {
         key: "_hash",
+        titleLong: "Hash",
+        titleShort: "Hash",
         type: "string"
       },
       {
         key: "a",
+        titleLong: "Column A",
+        titleShort: "A",
         type: "string"
       },
       {
         key: "b",
+        titleLong: "Column B",
+        titleShort: "B",
         type: "number"
       }
     ],
@@ -918,7 +1099,150 @@ const exampleTableCfg = (tableCfg = void 0) => {
   };
 };
 // @license
-const exampleEditsTable = () => bakeryExample().ingredientsEdits;
+const createHistoryTableCfg = (tableCfg) => ({
+  key: `${tableCfg.key}History`,
+  type: "history",
+  columns: [
+    { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+    {
+      key: "timeId",
+      type: "string",
+      titleLong: "Time ID",
+      titleShort: "Time ID"
+    },
+    {
+      key: `${tableCfg.key}Ref`,
+      type: "string",
+      titleLong: "Reference",
+      titleShort: "Ref"
+    },
+    { key: "route", type: "string", titleLong: "Route", titleShort: "Route" },
+    {
+      key: "origin",
+      type: "string",
+      titleLong: "Origin",
+      titleShort: "Origin"
+    },
+    {
+      key: "previous",
+      type: "jsonArray",
+      titleLong: "Previous",
+      titleShort: "Previous"
+    }
+  ],
+  isHead: false,
+  isRoot: false,
+  isShared: false
+});
+const exampleHistoryTable = () => bakeryExample().ingredientsHistory;
+// @license
+const objectDepth = (o) => Object(o) === o ? 1 + Math.max(-1, ...Object.values(o).map(objectDepth)) : 0;
+// @license
+class InsertValidator {
+  constructor(_insert) {
+    this._insert = _insert;
+  }
+  errors = { hasErrors: false };
+  // ............................................................................
+  /**
+   * Indicates whether there are any errors
+   * @returns boolean - True if there are errors, false otherwise
+   */
+  get hasErrors() {
+    return Object.keys(this.errors).length > 1;
+  }
+  // ............................................................................
+  /**
+   * Validates the Insert object
+   * @returns InsertErrors - The errors found during validation
+   */
+  validate() {
+    if (typeof this._insert.route !== "string" || this._insert.route.length === 0) {
+      this.errors.parameterRouteInvalid = {
+        error: "Insert route must be a non-empty string.",
+        parameter: this._insert.route
+      };
+    }
+    if (!this._insert.command.startsWith("add") && !this._insert.command.startsWith("remove")) {
+      this.errors.parameterCommandInvalid = {
+        error: "Insert command must be starting with either 'add' or 'remove'.",
+        parameter: this._insert.command
+      };
+    }
+    if (typeof this._insert.value === "undefined" || typeof this._insert.value !== "object" || this._insert.value === null) {
+      this.errors.parameterValueInvalid = {
+        error: "Insert value must be a non-null object.",
+        parameter: this._insert.value
+      };
+    }
+    if (typeof this._insert.origin !== "undefined" && typeof this._insert.origin !== "string") {
+      this.errors.parameterOriginInvalid = {
+        error: "Insert origin must be a string if defined.",
+        parameter: this._insert.origin
+      };
+    }
+    const route = Route.fromFlat(this._insert.route);
+    if (!route.isValid) {
+      this.errors.routeInvalid = {
+        error: "Insert route is not valid.",
+        route: this._insert.route
+      };
+    }
+    if (route.isValid) {
+      const routeDepth = route.segments.length;
+      const valueDepth = objectDepth(this._insert.value);
+      if (routeDepth !== valueDepth) {
+        this.errors.dataRouteMismatch = {
+          error: "Insert route depth does not match value depth. Route depth must match the depth of the value object.",
+          route: this._insert.route,
+          routeDepth,
+          valueDepth
+        };
+      }
+    }
+    if (typeof this._insert.value === "object" && this._insert.value !== null) {
+      this._checkMatchingRefs(route, this._insert.value);
+    }
+    this.errors.hasErrors = this.hasErrors;
+    return this.errors;
+  }
+  // ............................................................................
+  /**
+   * Recursively checks that all reference keys in the value match the route segments
+   * @param route - The current route segment
+   * @param value - The current value object
+   */
+  _checkMatchingRefs(route, value) {
+    const next = route.next;
+    const keys = Object.keys(value);
+    for (const key of keys) {
+      if (key.endsWith("Ref") && value[key] !== null && value[key] !== void 0 && typeof value[key] !== "string") {
+        const refObj = value[key];
+        if (!next || next.tableKey !== key.slice(0, -3)) {
+          this.errors.parameterInvalid = {
+            error: `Insert value has a reference key "${key}" that does not match the next route segment.`,
+            parameter: this._insert.value
+          };
+          break;
+        }
+        if (route.deeper().next)
+          this._checkMatchingRefs(route.deeper(), refObj);
+      }
+    }
+  }
+  // ............................................................................
+  /**
+   * Creates an InsertValidator for the given Insert object
+   * @param insert - The Insert object to validate
+   * @returns InsertValidator - The InsertValidator instance
+   */
+  static create(insert) {
+    return new InsertValidator(insert);
+  }
+}
+const validateInsert = (insert) => {
+  return InsertValidator.create(insert).validate();
+};
 // @license
 const reservedFieldNames = ["_data"];
 const reservedTableKeys = [
@@ -977,6 +1301,12 @@ const removeDuplicates = (rljson) => {
 const timeId = () => {
   return nanoid(4) + ":" + Date.now();
 };
+const isTimeId = (id) => {
+  const parts = id.split(":");
+  if (parts.length !== 2) return false;
+  if (isNaN(Number(parts[1]))) return false;
+  return parts[0].length === 4;
+};
 // @license
 const contentTypes = [
   "buffets",
@@ -986,7 +1316,7 @@ const contentTypes = [
   "components",
   "revisions",
   "tableCfgs",
-  "edits"
+  "history"
 ];
 const exampleTypedefs = () => {
   return {
@@ -1876,17 +2206,19 @@ class Validate {
 export {
   BaseValidator,
   Example,
+  InsertValidator,
   Route,
   Validate,
   addColumnsToTableCfg,
   bakeryExample,
   contentTypes,
   createCakeTableCfg,
+  createHistoryTableCfg,
   createLayerTableCfg,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleComponentsTable,
-  exampleEditsTable,
+  exampleHistoryTable,
   exampleLayersTable,
   exampleRevision,
   exampleRljson,
@@ -1894,6 +2226,7 @@ export {
   exampleTableCfg,
   exampleTableCfgTable,
   exampleTypedefs,
+  isTimeId,
   isValidFieldName,
   iterateTables,
   iterateTablesSync,
@@ -1902,5 +2235,6 @@ export {
   reservedTableKeys,
   throwOnInvalidTableCfg,
   timeId,
+  validateInsert,
   validateRljsonAgainstTableCfg
 };

package/dist/route/route.d.ts

@@ -0,0 +1,93 @@
+import { TableKey } from '../typedefs.ts';
+export type RouteRef = string;
+export type RouteSegment<Str extends string> = {
+    [key in Str as `${Uncapitalize<string & key>}Ref`]: string;
+} & {
+    tableKey: TableKey;
+};
+export type RouteSegmentFlat<N extends string> = `${N}` | `${N}@${string}` | `${N}@${string}:${string}`;
+/**
+ * A class to handle routes in an Rljson object.
+ */
+export declare class Route {
+    private readonly _segments;
+    constructor(_segments: RouteSegment<any>[]);
+    /**
+     * Creates a Route from a flat string representation.
+     * @param route - The flat string representation of the route (e.g. "/a/b/c")
+     * @returns A Route object
+     */
+    static fromFlat(route: string): Route;
+    /**
+     * Returns the segment at the given index or the last segment if no index is provided.
+     * @param index - The index of the segment to return (optional)
+     * @returns The segment at the given index or the last segment
+     */
+    segment(index?: number): RouteSegment<any>;
+    /**
+     * Returns a new Route that is one level deeper than the current route.
+     * If steps is provided, it returns a new Route that is 'steps' levels deeper.
+     * @param steps - The number of levels to go deeper (optional)
+     * @returns A new Route that is one level deeper or 'steps' levels deeper
+     */
+    deeper(steps?: number): Route;
+    /**
+     * Checks if the current route is the root route.
+     * @returns True if the current route is the root route, false otherwise
+     */
+    get isRoot(): boolean;
+    /**
+     * Returns the flat string representation of the route.
+     * @returns The flat string representation of the route (e.g. "/a/b/c")
+     */
+    get flat(): string;
+    /**
+     * Returns the segments of the route as an array of strings.
+     * @returns The segments of the route as an array of strings
+     */
+    get segments(): RouteSegment<any>[];
+    /**
+     * Returns the root segment of the route.
+     * @returns The root segment of the route
+     */
+    get root(): RouteSegment<any>;
+    /**
+     * Returns the top level segment of the route.
+     * @returns The top level segment of the route
+     */
+    get top(): RouteSegment<any>;
+    /**
+     * Returns the next segment of the route if it exists.
+     * @returns The next segment of the route or undefined if it doesn't exist
+     */
+    get next(): RouteSegment<any> | undefined;
+    /**
+     * Checks if the route is valid (i.e. has at least one segment and no empty segments).
+     * @returns True if the route is valid, false otherwise
+     */
+    get isValid(): boolean;
+    /**
+     * Returns the reference of a segment if it exists.
+     * @param segment - The segment to get the reference from
+     * @returns The reference of the segment or undefined if it doesn't exist
+     */
+    static segmentRef(segment: RouteSegment<any>): string | undefined;
+    /**
+     * Checks if a segment has any reference (either default or history).
+     * @param segment - The segment to check
+     * @returns True if the segment has any reference, false otherwise
+     */
+    static segmentHasRef(segment: RouteSegment<any>): boolean;
+    /**
+     * Checks if a segment has a default reference (i.e. not a history reference).
+     * @param segment - The segment to check
+     * @returns True if the segment has a default reference, false otherwise
+     */
+    static segmentHasDefaultRef(segment: RouteSegment<any>): boolean;
+    /**
+     * Checks if a segment has a history reference (i.e. an HistoryRef).
+     * @param segment - The segment to check
+     * @returns True if the segment has a history reference, false otherwise
+     */
+    static segmentHasHistoryRef(segment: RouteSegment<any>): boolean;
+}

package/dist/src/example.ts

@@ -16,6 +16,7 @@ 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(),
@@ -55,38 +56,56 @@ export class Example {
               {
                 key: '_hash',
                 type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
               },
               {
                 key: 'int',
                 type: 'number',
+                titleLong: 'Integer',
+                titleShort: 'Int',
               },
               {
                 key: 'double',
                 type: 'number',
+                titleLong: 'Double',
+                titleShort: 'Double',
               },
               {
                 key: 'string',
                 type: 'string',
+                titleLong: 'String',
+                titleShort: 'String',
               },
               {
                 key: 'boolean',
                 type: 'boolean',
+                titleLong: 'Boolean',
+                titleShort: 'Boolean',
               },
               {
                 key: 'null',
                 type: 'string',
+                titleLong: 'Null',
+                titleShort: 'Null',
               },
               {
                 key: 'jsonArray',
                 type: 'jsonArray',
+                titleLong: 'JSON Array',
+                titleShort: 'JSONArray',
               },
               {
                 key: 'json',
                 type: 'json',
+                titleLong: 'JSON Object',
+                titleShort: 'JSONObject',
               },
               {
                 key: 'jsonValue',
                 type: 'jsonValue',
+                titleLong: 'JSON Value',
+                titleShort: 'JSONValue',
               },
             ],
           },

package/dist/tools/object-depth.d.ts

@@ -0,0 +1 @@
+export declare const objectDepth: (o: object) => number;

package/dist/tools/time-id.d.ts

@@ -1 +1,17 @@
+/**
+ * Generates a new TimeId.
+ * A TimeId is a string in the format "xxxx:timestamp" where:
+ * - "xxxx" is a 4-character unique identifier
+ * - "timestamp" is the current time in milliseconds since epoch
+ * @returns A new TimeId string
+ */
 export declare const timeId: () => string;
+/**
+ * Checks if a given id is a valid TimeId.
+ * A valid TimeId has the format "xxxx:timestamp" where:
+ * - "xxxx" is a 4-character string
+ * - "timestamp" is a valid number representing milliseconds since epoch
+ * @param id - The id to check
+ * @returns True if the id is a valid TimeId, false otherwise
+ */
+export declare const isTimeId: (id: string) => boolean;

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", "edits"];
+export declare const contentTypes: readonly ["buffets", "cakes", "layers", "sliceIds", "components", "revisions", "tableCfgs", "history"];
 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.61",
+  "version": "0.0.64",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",
@@ -20,20 +20,20 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@types/node": "^24.6.1",
-    "@typescript-eslint/eslint-plugin": "^8.45.0",
-    "@typescript-eslint/parser": "^8.45.0",
+    "@types/node": "^24.9.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
     "@vitest/coverage-v8": "^3.2.4",
     "cross-env": "^10.1.0",
-    "eslint": "^9.36.0",
-    "eslint-plugin-jsdoc": "^60.7.0",
+    "eslint": "^9.38.0",
+    "eslint-plugin-jsdoc": "^61.1.5",
     "eslint-plugin-tsdoc": "^0.4.0",
     "globals": "^16.4.0",
-    "jsdoc": "^4.0.4",
+    "jsdoc": "^4.0.5",
     "read-pkg": "^9.0.1",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.45.0",
-    "vite": "^7.1.7",
+    "typescript-eslint": "^8.46.2",
+    "vite": "^7.1.11",
     "vite-node": "^3.2.4",
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^5.1.4",

package/dist/edit/edit.d.ts

@@ -1,29 +0,0 @@
-import { Json, JsonH, JsonValueH } from '@rljson/json';
-import { Ref } from '../typedefs.ts';
-import { RouteRef } from './route.ts';
-import { RljsonTable } from '../rljson.ts';
-/**
- * An Edit Object describing edits on data basically
- */
-export type EditRef = Ref;
-export type Edit<T extends Json> = {
-    value: T & JsonValueH;
-    route: RouteRef;
-    origin?: Ref;
-    previous?: EditProtocolTimeId[];
-    acknowledged?: boolean;
-} & JsonH;
-export type EditProtocolTimeId = string;
-export type EditProtocolRow<Str extends string> = {
-    [key in Str as `${Uncapitalize<string & key>}Ref`]: string;
-} & {
-    timeId: EditProtocolTimeId;
-    route: RouteRef;
-    origin?: Ref;
-    previous?: EditProtocolTimeId[];
-};
-export type EditProtocol<Str extends string> = RljsonTable<EditProtocolRow<Str>, 'edits'>;
-/**
- * Provides an example Edits table for test purposes
- */
-export declare const exampleEditsTable: () => EditProtocol<any>;

package/dist/edit/route.d.ts

@@ -1,13 +0,0 @@
-export type RouteRef = string;
-/**
- * A class to handle routes in an Rljson object.
- */
-export declare class Route {
-    private segments;
-    constructor(segments: string[]);
-    static fromFlat(route: string): Route;
-    segment(index?: number): string;
-    deeper(steps?: number): Route;
-    get isRoot(): boolean;
-    get flat(): string;
-}