@rljson/rljson 0.0.16 → 0.0.18

package/dist/content/buffet.d.ts

@@ -0,0 +1,31 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref, TableName } from '../typedefs.ts';
+/**
+ * A buffet id is a name or id of a buffet
+ */
+export type BuffetId = ItemId;
+/**
+ * A buffet is a collection of arbitrary but related items, e.g. cakes,
+ * collections, or items.
+ */
+export interface Buffet extends Json {
+    /**
+     * The items of the buffet
+     */
+    items: Array<{
+        /**
+         * The table the item is taken from
+         */
+        table: TableName;
+        /**
+         * The hash of the item in the able
+         */
+        ref: Ref;
+    }>;
+}
+/**
+ * A table containing buffets
+ */
+export type BuffetsTable = RljsonTable<Buffet, 'buffets'>;
+export declare const exampleBuffetsTable: () => BuffetsTable;

package/dist/content/cake.d.ts

@@ -0,0 +1,40 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, TableName } from '../typedefs.ts';
+import { CollectionRef } from './collection.ts';
+import { IdSetRef } from './id-set.ts';
+/**
+ * A `CakeLayerId` assigns an id or name to a cake layer
+ */
+export type CakeLayerId = ItemId;
+/**
+ * A cake is a collection of layers.
+ *
+ * A layer is a collection of items.
+ * All layers of a cake refer to the same items.
+ */
+export interface Cake extends Json {
+    /**
+     * The item ids of the collection. If present, the item ids in the layers
+     * must match these ids. The item id sets can be found in the _idSets table.
+     */
+    idSet?: IdSetRef;
+    /**
+     * The table containing the item collections defining the layers
+     */
+    collections: TableName;
+    /**
+     * Assigns a collection to each layer of the cake.
+     */
+    layers: {
+        [layerId: CakeLayerId]: CollectionRef;
+    };
+}
+/**
+ * A table containing cakes
+ */
+export type CakesTable = RljsonTable<Cake, 'cakes'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const exampleCakesTable: () => CakesTable;

package/dist/content/collection.d.ts

@@ -0,0 +1,40 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref, TableName } from '../typedefs.ts';
+import { IdSetRef } from './id-set.ts';
+import { PropertiesRef } from './properties.ts';
+/**
+ * A CollectionRef is a hash pointing to a collection
+ */
+export type CollectionRef = Ref;
+/**
+ * A collection assigns properties to item ids
+ */
+export interface Collection extends Json {
+    /**
+     * `base` an optional base collection that is extended by this collection
+     */
+    base?: CollectionRef;
+    /**
+     * The item ids of the collection. If presnet, the item ids in `assign`
+     * must match these ids. The item id sets can be found in the _idSets table.
+     */
+    idSet?: IdSetRef;
+    /**
+     * The table containing the properties that are assigned to the items
+     * with the assign property below
+     */
+    properties: TableName;
+    /**
+     * Assign properties to each item of the collection.
+     */
+    assign: Record<ItemId, PropertiesRef>;
+}
+/**
+ * A table containing collections
+ */
+export type CollectionsTable = RljsonTable<Collection, 'collections'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const exampleCollectionsTable: () => CollectionsTable;

package/dist/content/id-set.d.ts

@@ -0,0 +1,33 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref } from '../typedefs.ts';
+/**
+ * An IdSetRef is a hash pointing to an Ids
+ */
+export type IdSetRef = Ref;
+/**
+ * An Ids manages list of item ids
+ */
+export interface IdSet extends Json {
+    /**
+     * The hash of another item id list which is extended by this one.
+     * Must be empty or null, when the list is the root.
+     */
+    base?: IdSetRef;
+    /**
+     * The item ids added to base
+     */
+    add: ItemId[];
+    /**
+     * The item ids removed from base
+     */
+    remove?: ItemId[];
+}
+/**
+ * A table containing item ids
+ */
+export type IdSetsTable = RljsonTable<IdSet, 'idSets'>;
+/**
+ * Returns one of the layers of the example cake
+ */
+export declare const exampleIdSetsTable: () => IdSetsTable;

package/dist/content/properties.d.ts

@@ -0,0 +1,16 @@
+import { Json } from '@rljson/json';
+import { NutritiveValues } from '../example/bakery-example.ts';
+import { RljsonTable } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+/**
+ * A reference to a properties row in a properties table
+ */
+export type PropertiesRef = Ref;
+/**
+ * A table containing item properties
+ */
+export type PropertiesTable<T extends Json> = RljsonTable<T, 'properties'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const examplePropertiesTable: () => PropertiesTable<NutritiveValues>;

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

@@ -0,0 +1,48 @@
+import { Json, JsonKey, JsonValueType } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+/**
+ * A ColumnsRef is a hash pointing to columns metadata
+ */
+export type TableCfgRef = Ref;
+/**
+ * A column configuration
+ */
+export interface ColumnCfg extends Json {
+    /**
+     * The jsonKey of the column used in data
+     */
+    jsonKey: JsonKey;
+    /**
+     * A short name of the column to be shown in the table header
+     */
+    nameShort: string;
+    /**
+     * A unshorted name to be shown in the tool tip
+     */
+    name: string;
+    /**
+     * Average number of characters in the column
+     */
+    avgChars?: number;
+    /**
+     * The type of the column
+     */
+    type: JsonValueType;
+}
+/**
+ * Describes the configuration of a table, i.e. table metadata and columns
+ */
+export interface TableCfg extends Json {
+    name: string;
+    jsonKey: JsonKey;
+    columns: Record<JsonKey, ColumnCfg>;
+}
+/**
+ * A table containing columns
+ */
+export type TablesCfgTable = RljsonTable<TableCfg, 'properties'>;
+/**
+ * Example matching allTypesRow
+ */
+export declare const exampleTableCfgTable: () => TablesCfgTable;

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

@@ -0,0 +1,35 @@
+import { Json } from '@rljson/json';
+import { BuffetsTable } from '../content/buffet.ts';
+import { CakesTable } from '../content/cake.ts';
+import { CollectionsTable } from '../content/collection.ts';
+import { IdSetsTable } from '../content/id-set.ts';
+import { PropertiesTable } from '../content/properties.ts';
+import { Rljson } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+export interface Ingredient extends Json {
+    name: string;
+    amountUnit: 'g' | 'ml';
+    nutritiveValuesRef: Ref;
+}
+export interface RecipeIngredient extends Json {
+    ingredientsRef: string;
+    quantity: number;
+}
+export type IngredientsTypeTable = PropertiesTable<Ingredient>;
+export interface NutritiveValues extends Json {
+    energy: number;
+    fat: number;
+    protein: number;
+    carbohydrates: number;
+}
+export interface Bakery extends Rljson {
+    buffets: BuffetsTable;
+    cakes: CakesTable;
+    slices: IdSetsTable;
+    layers: CollectionsTable;
+    recipes: CollectionsTable;
+    recipeIngredients: PropertiesTable<RecipeIngredient>;
+    ingredients: PropertiesTable<Ingredient>;
+    nutritiveValues: PropertiesTable<NutritiveValues>;
+}
+export declare const bakeryExample: () => Bakery;

package/dist/rljson.js

@@ -532,7 +532,7 @@ const exampleTypedefs = () => {
 // @license
 class BaseValidator {
   constructor() {
-    __publicField(this, "name", "syntax");
+    __publicField(this, "name", "base");
   }
   async validate(rljson) {
     return this.validateSync(rljson);
@@ -1172,7 +1172,7 @@ class Validate {
     return result.reduce((acc, errors) => {
       let hasErrors = false;
       for (const key of Object.keys(errors)) {
-        const e = Object.keys(errors[key]);
+        const e = Object.keys(errors[key]).filter((k) => k !== "hasErrors");
         if (e.length > 0) {
           hasErrors = true;
           break;

package/dist/validate/base-validator.d.ts

@@ -0,0 +1,39 @@
+import { Json } from '@rljson/json';
+import { Rljson } from '../rljson.ts';
+import { Errors, Validator } from './validate.ts';
+export interface BaseErrors extends Errors {
+    tableNamesNotLowerCamelCase?: Json;
+    columnNamesNotLowerCamelCase?: Json;
+    tableNamesDoNotStartWithANumber?: Json;
+    tableNamesDoNotEndWithRef?: Json;
+    hashesNotValid?: Json;
+    dataNotFound?: Json;
+    dataHasWrongType?: Json;
+    tableCfgsReferencedTableNameNotFound?: Json;
+    tableCfgsHaveWrongTypes?: Json;
+    tableCfgReferencedNotFound?: Json;
+    columnConfigNotFound?: Json;
+    dataDoesNotMatchColumnConfig?: Json;
+    refsNotFound?: Json;
+    collectionBasesNotFound?: Json;
+    collectionIdSetsNotFound?: Json;
+    collectionPropertyTablesNotFound?: Json;
+    collectionPropertyAssignmentsNotFound?: Json;
+    cakeIdSetsNotFound?: Json;
+    cakeCollectionTablesNotFound?: Json;
+    cakeLayerCollectionsNotFound?: Json;
+    buffetReferencedTablesNotFound?: Json;
+    buffetReferencedItemsNotFound?: Json;
+}
+export declare class BaseValidator implements Validator {
+    name: string;
+    validate(rljson: Rljson): Promise<Errors>;
+    validateSync(rljson: Rljson): BaseErrors;
+    static isValidFieldName(fieldName: string): boolean;
+}
+/**
+ * Validates an field name
+ * @param fieldName - The field name to validate
+ * @returns true if the field name is valid, false otherwise
+ */
+export declare const isValidFieldName: (fieldName: string) => boolean;

package/dist/validate/validate.d.ts

@@ -0,0 +1,19 @@
+import { Json } from '@rljson/json';
+import { Rljson } from '../rljson.ts';
+export type Errors = Json & {
+    hasErrors: boolean;
+};
+export interface ValidationResult {
+    [group: string]: Errors;
+}
+export interface Validator {
+    name: string;
+    validate(rljson: Rljson): Promise<Errors>;
+}
+export declare class Validate {
+    addValidator(validator: Validator): void;
+    run(rljson: Rljson): Promise<{
+        [group: string]: Errors;
+    }>;
+    private _validators;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "packageManager": "pnpm@10.6.3",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",