@rljson/rljson 0.0.62 → 0.0.64

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,8 +5,9 @@ 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-validator.ts';
-export * from './edit/edit.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';

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

@@ -17,7 +17,7 @@ class Route {
     const segments = [];
     for (const segmentFlat of segmentsFlat) {
       const [tableKey, refFlat] = segmentFlat.split("@");
-      const ref = !!refFlat ? refFlat.split(":").length == 2 ? { [tableKey + "EditsRef"]: refFlat } : { [tableKey + "Ref"]: refFlat } : {};
+      const ref = !!refFlat ? refFlat.split(":").length == 2 ? { [tableKey + "HistoryRef"]: refFlat } : { [tableKey + "Ref"]: refFlat } : {};
       const segment = {
         tableKey,
         ...ref
@@ -139,7 +139,7 @@ class Route {
   }
   // .............................................................................
   /**
-   * Checks if a segment has any reference (either default or protocol).
+   * 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
    */
@@ -148,21 +148,21 @@ class Route {
   }
   // .............................................................................
   /**
-   * Checks if a segment has a default reference (i.e. not a protocol reference).
+   * 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.segmentHasProtocolRef(segment);
+    return this.segmentHasRef(segment) && !this.segmentHasHistoryRef(segment);
   }
   // .............................................................................
   /**
-   * Checks if a segment has a protocol reference (i.e. an EditsRef).
+   * 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 protocol reference, false otherwise
+   * @returns True if the segment has a history reference, false otherwise
    */
-  static segmentHasProtocolRef(segment) {
-    return this.segmentHasRef(segment) && Object.keys(segment).some((k) => k.endsWith("EditsRef"));
+  static segmentHasHistoryRef(segment) {
+    return this.segmentHasRef(segment) && Object.keys(segment).some((k) => k.endsWith("HistoryRef"));
   }
 }
 // @license
@@ -293,8 +293,8 @@ const bakeryExample = () => {
       }
     ]
   });
-  const ingredientsEdits = hip({
-    _type: "edits",
+  const ingredientsHistory = hip({
+    _type: "history",
     _data: [
       {
         timeId: "de72:1759123957292",
@@ -323,7 +323,7 @@ const bakeryExample = () => {
     recipeIngredients,
     ingredients,
     nutritionalValues,
-    ingredientsEdits
+    ingredientsHistory
   };
   return result;
 };
@@ -334,11 +334,21 @@ const createCakeTableCfg = (cakeKey) => ({
   key: cakeKey,
   type: "cakes",
   columns: [
-    { key: "_hash", type: "string" },
-    { key: "sliceIdsTable", type: "string" },
-    { key: "sliceIdsRow", type: "string" },
-    { key: "layers", type: "json" },
-    { 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,
@@ -352,13 +362,28 @@ const createLayerTableCfg = (layerKey) => ({
   key: layerKey,
   type: "layers",
   columns: [
-    { key: "_hash", type: "string" },
-    { key: "base", type: "string" },
-    { key: "sliceIdsTable", type: "string" },
-    { key: "sliceIdsTableRow", type: "string" },
-    { key: "componentsTable", type: "string" },
-    { key: "add", type: "json" },
-    { key: "remove", type: "json" }
+    { 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,
@@ -411,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"
               }
             ]
           }
@@ -1032,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"
       }
     ],
@@ -1050,66 +1099,119 @@ const exampleTableCfg = (tableCfg = void 0) => {
   };
 };
 // @license
+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 EditValidator {
-  constructor(_edit) {
-    this._edit = _edit;
+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._edit.route !== "string" || this._edit.route.length === 0) {
+    if (typeof this._insert.route !== "string" || this._insert.route.length === 0) {
       this.errors.parameterRouteInvalid = {
-        error: "Edit route must be a non-empty string.",
-        parameter: this._edit.route
+        error: "Insert route must be a non-empty string.",
+        parameter: this._insert.route
       };
     }
-    if (!this._edit.command.startsWith("add") && !this._edit.command.startsWith("remove")) {
+    if (!this._insert.command.startsWith("add") && !this._insert.command.startsWith("remove")) {
       this.errors.parameterCommandInvalid = {
-        error: "Edit command must be starting with either 'add' or 'remove'.",
-        parameter: this._edit.command
+        error: "Insert command must be starting with either 'add' or 'remove'.",
+        parameter: this._insert.command
       };
     }
-    if (typeof this._edit.value === "undefined" || typeof this._edit.value !== "object" || this._edit.value === null) {
+    if (typeof this._insert.value === "undefined" || typeof this._insert.value !== "object" || this._insert.value === null) {
       this.errors.parameterValueInvalid = {
-        error: "Edit value must be a non-null object.",
-        parameter: this._edit.value
+        error: "Insert value must be a non-null object.",
+        parameter: this._insert.value
       };
     }
-    if (typeof this._edit.origin !== "undefined" && typeof this._edit.origin !== "string") {
+    if (typeof this._insert.origin !== "undefined" && typeof this._insert.origin !== "string") {
       this.errors.parameterOriginInvalid = {
-        error: "Edit origin must be a string if defined.",
-        parameter: this._edit.origin
+        error: "Insert origin must be a string if defined.",
+        parameter: this._insert.origin
       };
     }
-    const route = Route.fromFlat(this._edit.route);
+    const route = Route.fromFlat(this._insert.route);
     if (!route.isValid) {
       this.errors.routeInvalid = {
-        error: "Edit route is not valid.",
-        route: this._edit.route
+        error: "Insert route is not valid.",
+        route: this._insert.route
       };
     }
     if (route.isValid) {
       const routeDepth = route.segments.length;
-      const valueDepth = objectDepth(this._edit.value);
+      const valueDepth = objectDepth(this._insert.value);
       if (routeDepth !== valueDepth) {
         this.errors.dataRouteMismatch = {
-          error: "Edit route depth does not match value depth. Route depth must match the depth of the value object.",
-          route: this._edit.route,
+          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._edit.value === "object" && this._edit.value !== null) {
-      this._checkMatchingRefs(route, this._edit.value);
+    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);
@@ -1118,8 +1220,8 @@ class EditValidator {
         const refObj = value[key];
         if (!next || next.tableKey !== key.slice(0, -3)) {
           this.errors.parameterInvalid = {
-            error: `Edit value has a reference key "${key}" that does not match the next route segment.`,
-            parameter: this._edit.value
+            error: `Insert value has a reference key "${key}" that does not match the next route segment.`,
+            parameter: this._insert.value
           };
           break;
         }
@@ -1128,31 +1230,20 @@ class EditValidator {
       }
     }
   }
-  static create(edit) {
-    return new EditValidator(edit);
+  // ............................................................................
+  /**
+   * 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 validateEdit = (edit) => {
-  return EditValidator.create(edit).validate();
+const validateInsert = (insert) => {
+  return InsertValidator.create(insert).validate();
 };
 // @license
-const createEditProtocolTableCfg = (tableCfg) => ({
-  key: `${tableCfg.key}Edits`,
-  type: "edits",
-  columns: [
-    { key: "_hash", type: "string" },
-    { key: "timeId", type: "string" },
-    { key: `${tableCfg.key}Ref`, type: "string" },
-    { key: "route", type: "string" },
-    { key: "origin", type: "string" },
-    { key: "previous", type: "jsonArray" }
-  ],
-  isHead: false,
-  isRoot: false,
-  isShared: false
-});
-const exampleEditsTable = () => bakeryExample().ingredientsEdits;
-// @license
 const reservedFieldNames = ["_data"];
 const reservedTableKeys = [
   "_hash",
@@ -1225,7 +1316,7 @@ const contentTypes = [
   "components",
   "revisions",
   "tableCfgs",
-  "edits"
+  "history"
 ];
 const exampleTypedefs = () => {
   return {
@@ -2114,20 +2205,20 @@ class Validate {
 }
 export {
   BaseValidator,
-  EditValidator,
   Example,
+  InsertValidator,
   Route,
   Validate,
   addColumnsToTableCfg,
   bakeryExample,
   contentTypes,
   createCakeTableCfg,
-  createEditProtocolTableCfg,
+  createHistoryTableCfg,
   createLayerTableCfg,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleComponentsTable,
-  exampleEditsTable,
+  exampleHistoryTable,
   exampleLayersTable,
   exampleRevision,
   exampleRljson,
@@ -2144,6 +2235,6 @@ export {
   reservedTableKeys,
   throwOnInvalidTableCfg,
   timeId,
-  validateEdit,
+  validateInsert,
   validateRljsonAgainstTableCfg
 };

package/dist/route/route.d.ts

@@ -73,21 +73,21 @@ export declare class Route {
      */
     static segmentRef(segment: RouteSegment<any>): string | undefined;
     /**
-     * Checks if a segment has any reference (either default or protocol).
+     * 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 protocol reference).
+     * 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 protocol reference (i.e. an EditsRef).
+     * 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 protocol reference, false otherwise
+     * @returns True if the segment has a history reference, false otherwise
      */
-    static segmentHasProtocolRef(segment: RouteSegment<any>): boolean;
+    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/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.62",
+  "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.7.2",
-    "@typescript-eslint/eslint-plugin": "^8.46.0",
-    "@typescript-eslint/parser": "^8.46.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.37.0",
-    "eslint-plugin-jsdoc": "^61.1.1",
+    "eslint": "^9.38.0",
+    "eslint-plugin-jsdoc": "^61.1.5",
     "eslint-plugin-tsdoc": "^0.4.0",
     "globals": "^16.4.0",
     "jsdoc": "^4.0.5",
     "read-pkg": "^9.0.1",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.46.0",
-    "vite": "^7.1.9",
+    "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-validator.d.ts

@@ -1,24 +0,0 @@
-import { Json } from '@rljson/json';
-import { Errors } from '../validate/validate.ts';
-import { Edit } from './edit.ts';
-export interface EditErrors extends Errors {
-    invalidObject?: Json;
-    parameterInvalid?: Json;
-    parameterRouteInvalid?: Json;
-    parameterCommandInvalid?: Json;
-    parameterValueInvalid?: Json;
-    parameterOriginInvalid?: Json;
-    parameterPreviousInvalid?: Json;
-    routeInvalid?: Json;
-    dataRouteMismatch?: Json;
-}
-export declare class EditValidator<T extends Json> {
-    private _edit;
-    errors: EditErrors;
-    get hasErrors(): boolean;
-    constructor(_edit: Edit<T>);
-    validate(): EditErrors;
-    private _checkMatchingRefs;
-    static create(edit: Edit<any>): EditValidator<any>;
-}
-export declare const validateEdit: (edit: Edit<any>) => EditErrors;

package/dist/edit/edit.d.ts

@@ -1,41 +0,0 @@
-import { Json } from '@rljson/json';
-import { Ref } from '../typedefs.ts';
-import { TableCfg } from '../content/table-cfg.ts';
-import { RljsonTable } from '../rljson.ts';
-import { RouteRef } from '../route/route.ts';
-/**
- * An Edit Object describing edits on data basically
- */
-export type EditRef = Ref;
-export type EditCommand = 'add' | 'remove';
-/**
- * An Edit describes a change to be applied to an Rljson object.
- * @param T - The type of the value being edited, extending Json
- */
-export type Edit<T extends Json> = {
-    command: EditCommand;
-    value: T;
-    route: RouteRef;
-    origin?: Ref;
-    acknowledged?: boolean;
-};
-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'>;
-/**
- * Creates a TableCfg for an Edit Protocol table for the given table configuration
- * @param tableCfg - The table configuration to create the Edit Protocol table for
- * @returns The TableCfg for the Edit Protocol table
- */
-export declare const createEditProtocolTableCfg: (tableCfg: TableCfg) => TableCfg;
-/**
- * Provides an example Edits table for test purposes
- */
-export declare const exampleEditsTable: () => EditProtocol<any>;