@rentman/rm-core 0.0.0-RM4-44763

package/dist/types/src/types/ItemTypesCollection.d.ts

@@ -0,0 +1,416 @@
+import { Signal } from '@angular/core';
+import { ApiEnumApiType, ApiFields, ApiItemType, GetColumnType, ItemId, RequestParameters as BackendTypesRequestParameters, ResponseColumnItem, RmLoginInfoFlag } from '@rentman/backend-types';
+import { UnknownResponseColumn } from '@rentman/backend-types/dist/manual/api-response-column';
+import moment from 'moment';
+import { ApiQuery, ChangesDeltaItemUpdateMode, ItemEntry, ItemResource, RequestColumnExpansion } from '../internal';
+export type DerivedStringToRequestColumnPath<StringType extends string> = StringType extends `${infer Head}>${infer Tail}` ? readonly [Head, ...DerivedStringToRequestColumnPath<Tail>] : readonly [StringType];
+export type ResolveDerivedValue<ItemTypeType extends ApiItemType, ColumnPath extends readonly string[]> = ColumnPath extends readonly [infer Last] ? Last extends ItemTypeColumnId<ItemTypeType> ? GetFieldValueType<ItemTypeType, Last> : never : ColumnPath extends readonly [infer First, ...infer Rest] ? First extends ItemTypeColumnId<ItemTypeType> ? Rest extends readonly string[] ? ResolveDerivedValue<ExtractApiItemType<GetColumnType<ItemTypeType, First>>, Rest> : never : never : never;
+export type ResolveDerivedValues<ItemTypeType extends ApiItemType, ColumnPath extends readonly string[]> = ColumnPath extends readonly [infer Last] ? Last extends ItemTypeColumnId<ItemTypeType> ? FieldMap<ExtractApiItemType<GetColumnType<ItemTypeType, Last>>> : never : ColumnPath extends readonly [infer First, ...infer Rest] ? First extends ItemTypeColumnId<ItemTypeType> ? Rest extends readonly string[] ? ResolveDerivedValues<ExtractApiItemType<GetColumnType<ItemTypeType, First>>, Rest> : never : never : never;
+export type ApiEnumApiTypeToTsTypeMap = {
+    [ApiEnumApiType.TYPE_TOKEN]: string;
+    [ApiEnumApiType.TYPE_ID]: number;
+    [ApiEnumApiType.TYPE_ORDER]: number;
+    [ApiEnumApiType.TYPE_PARENTID]: number;
+    [ApiEnumApiType.TYPE_PARENTTYPE]: ApiItemType;
+    [ApiEnumApiType.TYPE_ITEMID]: number;
+    [ApiEnumApiType.TYPE_ITEMTYPE]: ApiItemType;
+    [ApiEnumApiType.TYPE_PASSWORD]: string;
+    [ApiEnumApiType.TYPE_IP]: string;
+    [ApiEnumApiType.TYPE_COORDINATE]: number;
+    [ApiEnumApiType.TYPE_BLOB]: string;
+    [ApiEnumApiType.TYPE_BITFLAG]: number;
+    [ApiEnumApiType.TYPE_NUMBER]: number;
+    [ApiEnumApiType.TYPE_VOLUME]: number;
+    [ApiEnumApiType.TYPE_WEIGHT]: number;
+    [ApiEnumApiType.TYPE_DISTANCE]: number;
+    [ApiEnumApiType.TYPE_DIMENSION]: number;
+    [ApiEnumApiType.TYPE_QUANTITY]: number;
+    [ApiEnumApiType.TYPE_POWER]: number;
+    [ApiEnumApiType.TYPE_CURRENT]: number;
+    [ApiEnumApiType.TYPE_DOUBLE]: number;
+    [ApiEnumApiType.TYPE_PRICE]: number;
+    [ApiEnumApiType.TYPE_BOOL]: boolean;
+    [ApiEnumApiType.TYPE_INT]: number;
+    [ApiEnumApiType.TYPE_EMAIL]: string;
+    [ApiEnumApiType.TYPE_PHONE]: string;
+    [ApiEnumApiType.TYPE_URL]: string;
+    [ApiEnumApiType.TYPE_PERCENTAGE]: number;
+    [ApiEnumApiType.TYPE_TEXT]: string;
+    [ApiEnumApiType.TYPE_LONGTEXT]: string;
+    [ApiEnumApiType.TYPE_HTML]: string;
+    [ApiEnumApiType.TYPE_DATE]: moment.Moment;
+    [ApiEnumApiType.TYPE_DATETIME]: moment.Moment;
+    [ApiEnumApiType.TYPE_DURATION]: moment.Duration;
+    [ApiEnumApiType.TYPE_ITEM]: number;
+    [ApiEnumApiType.TYPE_LINK]: number;
+    [ApiEnumApiType.TYPE_CHILD]: number;
+    [ApiEnumApiType.TYPE_SIBLING]: number;
+    [ApiEnumApiType.TYPE_JSON]: any;
+    [ApiEnumApiType.TYPE_ENUM]: string;
+    [ApiEnumApiType.TYPE_COUNTRY]: string;
+    [ApiEnumApiType.TYPE_COLOR]: string;
+    [ApiEnumApiType.TYPE_TEXTREPLACE]: string;
+    [ApiEnumApiType.TYPE_FILESIZE]: number;
+    [ApiEnumApiType.TYPE_ICON]: string;
+    [ApiEnumApiType.TYPE_NUMERIC_EXTERNALID]: number;
+    [ApiEnumApiType.TYPE_ALPHANUMERIC_EXTERNALID]: string;
+    [ApiEnumApiType.TYPE_TIME]: string;
+    [ApiEnumApiType.TYPE_TIMESTAMP]: moment.Moment;
+    [ApiEnumApiType.TYPE_TIMESTAMP_MS]: moment.Moment;
+};
+export type ParentIdMap<T> = {
+    [parentId: string]: T;
+};
+export type EntryParent<ItemTypeType extends ApiItemType = any> = {
+    readonly itemType: ItemTypeType;
+    readonly itemId: ItemId;
+};
+export type EntryParentNull<ItemTypeType extends ApiItemType = ApiItemType> = EntryParent<ItemTypeType> | null;
+export type ItemTypeColumnId<ItemTypeType extends ApiItemType> = keyof ApiFields[ItemTypeType];
+export type ItemTypeColumnIds<ItemTypeType extends ApiItemType> = readonly ItemTypeColumnId<ItemTypeType>[];
+export type FieldMap<ItemTypeType extends ApiItemType = ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = {
+    [ColumnId in ColumnIds[number]]: GetFieldValueType<ItemTypeType, ColumnId>;
+};
+export type SignalFieldMap<ItemTypeType extends ApiItemType = ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = {
+    [ColumnId in ColumnIds[number]]: Signal<GetFieldValueType<ItemTypeType, ColumnId>>;
+};
+export type ExtractApiType<T> = T extends {
+    type: any;
+} ? T['type'] : never;
+export type ExtractApiEnum<T> = T extends {
+    enum: any;
+} ? T['enum'] : never;
+export type ExtractApiItemType<T> = T extends {
+    itemType: any;
+} ? T['itemType'] : never;
+export type ExtractApiNullable<T> = T extends {
+    nullable: any;
+} ? T['nullable'] : never;
+export type ExtractApiFieldType<T> = T extends {
+    type: keyof ApiEnumApiTypeToTsTypeMap;
+} ? ApiEnumApiTypeToTsTypeMap[T['type']] : never;
+export type GetFieldValueType<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]> = ExtractApiType<ApiFields[ItemTypeType][ColumnId]> extends ApiEnumApiType.TYPE_ENUM ? keyof ExtractApiEnum<ApiFields[ItemTypeType][ColumnId]> : GetNullableValueType<ItemTypeType, ColumnId>;
+type GetNullableValueType<ItemTypeType extends ApiItemType, ColumnId extends keyof ApiFields[ItemTypeType]> = ExtractApiNullable<ApiFields[ItemTypeType][ColumnId]> extends false ? ExtractApiFieldType<ApiFields[ItemTypeType][ColumnId]> : ExtractApiType<ApiFields[ItemTypeType][ColumnId]> extends ApiEnumApiType.TYPE_DATETIME | ApiEnumApiType.TYPE_DATE | ApiEnumApiType.TYPE_TIMESTAMP | ApiEnumApiType.TYPE_TIMESTAMP_MS | ApiEnumApiType.TYPE_DURATION ? ExtractApiFieldType<ApiFields[ItemTypeType][ColumnId]> : null | ExtractApiFieldType<ApiFields[ItemTypeType][ColumnId]>;
+export interface SocketMessageBase {
+    header: {
+        domain: string;
+        account: string;
+        sender: {
+            displayname: string;
+            itemType: 'Medewerker';
+            itemId: ItemId;
+            authorized: boolean;
+            session: string;
+        };
+        messageId: {
+            Id: string;
+            sequence: number;
+            batch: number;
+            request: number;
+        };
+        sent: string;
+        forceEvaluate: boolean;
+    };
+    messageType: string;
+    inResponse: boolean;
+}
+export interface SocketMessageCreate<ItemTypeType extends ApiItemType> extends SocketMessageBase {
+    messageType: 'event';
+    body: {
+        itemType: ItemTypeType;
+        eventType: 'create';
+        items: Pick<SocketUpdatedItems, ItemTypeType>;
+    };
+}
+export interface SocketMessageUpdate<ItemTypeType extends ApiItemType> extends SocketMessageBase {
+    messageType: 'event';
+    body: {
+        itemType: ItemTypeType;
+        eventType: 'update';
+        items: Pick<SocketUpdatedItems, ItemTypeType>;
+    };
+}
+export interface SocketMessageDelete extends SocketMessageBase {
+    messageType: 'event';
+    body: {
+        itemType: ApiItemType;
+        eventType: 'delete';
+        items: ItemId[];
+    };
+}
+export interface SocketMessageLinkTo<ItemTypeType extends ApiItemType> extends SocketMessageBase {
+    messageType: 'event';
+    body: {
+        itemType: ItemTypeType;
+        eventType: 'linkTo';
+        items: Pick<SocketUpdatedItems, ItemTypeType>;
+    };
+}
+type SocketUpdatedItems = {
+    [ItemType in ApiItemType]: {
+        [itemId: string]: SocketMessageValuesTuple<ItemType, ItemTypeColumnIds<ItemType>>;
+    };
+};
+export type SocketMessageValuesTuple<ItemTypeType extends ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType>> = {
+    parent: EntryParent | null;
+    values: FieldMap<ItemTypeType, ColumnIds>;
+};
+export type SocketMessage<ItemTypeType extends ApiItemType> = SocketMessageCreate<ItemTypeType> | SocketMessageUpdate<ItemTypeType> | SocketMessageLinkTo<ItemTypeType> | SocketMessageDelete;
+export type ItemResourcesItemTypeMap = {
+    [ItemTypeType in ApiItemType]?: ItemResource<ItemTypeType>[];
+};
+export type ItemMap<T> = {
+    [itemType: string]: {
+        [itemId: string]: T;
+    };
+};
+export type ParentItemMap<T> = {
+    [parentId: number]: {
+        [itemType: string]: T;
+    };
+};
+export type ItemEntryMap<ItemTypeType extends ApiItemType = any> = ItemMap<ItemEntry<ItemTypeType>>;
+export type ItemEntryParentIdMap<ItemTypeType extends ApiItemType> = ParentIdMap<ItemEntry<ItemTypeType>[]>;
+export type ConversionMap = {
+    [itemId: number]: number;
+};
+export type ItemIdConversionMap = {
+    [itemType: string]: ConversionMap;
+};
+export type CreateRequestParameterMap<T = any> = ItemMap<T>;
+export type ItemError = {
+    message: string;
+};
+export type CollectionQuery<ItemTypeType extends ApiItemType, IsLocallyMatchable extends boolean = boolean> = {
+    object: ApiQuery<ItemTypeType>;
+    string: string;
+    isLocallyMatchable: IsLocallyMatchable;
+};
+export type ResponseColumnMap<ItemTypeType extends ApiItemType = ApiItemType, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = {
+    [ColumnId in ColumnIds[number]]: GetColumnType<ItemTypeType, ColumnId>;
+};
+export type ResponseColumnItemTypeMap = {
+    [ItemTypeType in ApiItemType]: ResponseColumnMap<ItemTypeType, ItemTypeColumnIds<ItemTypeType>>;
+};
+export type RootColumnMap<ItemTypeType extends ApiItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = any> = {
+    [ColumnId in ColumnIds[number]]: {
+        apiColumn: GetColumnType<ItemTypeType, ColumnId>;
+        children: RootColumnMap;
+    };
+};
+export type ApiResponse<ItemTypeType extends ApiItemType = any> = {
+    columns: ItemTypeMap<UnknownResponseColumn[]>;
+    itemType: ItemTypeType;
+    items: ItemTypeMap<{
+        [itemId: string]: {
+            data: unknown[];
+            links: Record<ApiItemType, ItemId[]>;
+        };
+    }>;
+    links: Record<ApiItemType, ItemId[]>;
+    cacheable?: boolean;
+} & Record<string, unknown>;
+export type TemplateItemResourceMap<T extends ItemResource<any>> = {
+    main: T;
+    linked: ItemResourcesItemTypeMap;
+};
+export type ItemTypeMap<T = any> = {
+    [itemType: string]: T;
+};
+export type ApiRequestItemValues = {
+    values?: any;
+    links?: {
+        [itemType: string]: ItemId[];
+    };
+};
+export type ApiRequestItemMap = {
+    [itemType: string]: {
+        [itemId: number]: ApiRequestItemValues;
+    };
+};
+export type OnlyNonNever<T> = {
+    [P in keyof T]: T[P] extends never ? never : P;
+}[keyof T];
+export type GetColumnIdsOfType<ItemTypeType extends ApiItemType, ApiType extends ApiEnumApiType> = OnlyNonNever<{
+    [ColumnId in keyof ApiFields[ItemTypeType]]: ExtractApiType<ApiFields[ItemTypeType][ColumnId]> extends ApiType ? true : never;
+}>;
+export type GetDerivedColumnIds<ItemTypeType extends ApiItemType> = OnlyNonNever<{
+    [ColumnId in keyof ApiFields[ItemTypeType]]: GetColumnType<ItemTypeType, ColumnId> extends ResponseColumnItem ? true : never;
+}>;
+export type DerivedRequestColumnObject<ItemTypeType extends ApiItemType = any> = {
+    [ColumnId in GetDerivedColumnIds<ItemTypeType>]?: ApiRequestColumnArray<ExtractApiItemType<GetColumnType<ItemTypeType, ColumnId>>>;
+};
+export type ApiRequestColumn<ItemTypeType extends ApiItemType = any> = ItemTypeColumnId<ItemTypeType> | DerivedRequestColumnObject<ItemTypeType>;
+export type ApiRequestColumnArray<ItemTypeType extends ApiItemType = any> = readonly ApiRequestColumn<ItemTypeType>[];
+export type ApiRequestColumns<ItemTypeType extends ApiItemType = any> = ApiRequestColumnArray<ItemTypeType> | true;
+export type MutableApiRequestColumnArray<ItemTypeType extends ApiItemType = any> = ApiRequestColumn<ItemTypeType>[];
+/**
+ * Both the array and string representation are read-only, because whenever the object changes, the string representation
+ * should change too.
+ */
+export type RequestColumnsTuple<ItemTypeType extends ApiItemType = any> = {
+    readonly object: true;
+    readonly string: 'true';
+} | {
+    readonly object: ApiRequestColumns<ItemTypeType>;
+    readonly string: string;
+};
+export type ApiRequestColumnMap = {
+    [itemType: string]: ApiRequestColumns;
+};
+export type ApiRequestColumnArrayMap = {
+    [itemType in ApiItemType]?: ApiRequestColumnArray;
+};
+export type ApiRequestLimit<ItemTypeType extends ApiItemType = any> = {
+    field: ItemTypeColumnId<ItemTypeType>;
+    order?: 'desc' | 'asc';
+    limit: number;
+};
+export type CreateRequestEntry<ItemTypeType extends ApiItemType> = {
+    request: {
+        requestType: 'create';
+        itemType?: ItemTypeType;
+        parentType?: ApiItemType;
+        parentId?: {
+            [itemId: string]: ItemId;
+        };
+        items: ApiRequestItemMap;
+        columns: ApiRequestColumnMap;
+        uniqueTransactionId?: string;
+    };
+    columns: RequestColumnExpansion;
+    items: ItemEntryMap<ItemTypeType>;
+};
+export declare enum ApiLinkTreeType {
+    ITEMTABLE = "itemtable",
+    DIRECT = "direct"
+}
+export type ApiLinkTreeEntryItemTable = {
+    type: ApiLinkTreeType.ITEMTABLE;
+};
+export type ApiLinkTreeEntryDirect<ItemTypeType extends ApiItemType = any> = {
+    type: ApiLinkTreeType.DIRECT;
+    field: ItemTypeColumnId<ItemTypeType>;
+};
+export type ApiLinkTreeEntry<ItemTypeType extends ApiItemType = any> = ApiLinkTreeEntryItemTable | ApiLinkTreeEntryDirect<ItemTypeType>;
+export type ApiLinkTree = {
+    [itemType: string]: {
+        [childType: string]: ApiLinkTreeEntry;
+    };
+};
+/**
+ * @description
+ * Callback to determine if an item should be included in the create delta, return `false` to exclude the item
+ */
+export type FilterItemEntryCallback<ItemTypeType extends ApiItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = (itemType: ItemTypeType, fields: FieldMap<ItemTypeType, ColumnIds>) => boolean;
+export type ModifyFieldsCallback<ItemTypeType extends ApiItemType = any, ColumnIds extends ItemTypeColumnIds<ItemTypeType> = ItemTypeColumnIds<ItemTypeType>> = (itemType: ItemTypeType, fields: FieldMap<ItemTypeType, ColumnIds>, itemIdConversionMap?: ItemIdConversionMap) => void;
+export type DeregFunction = () => void;
+export type ResponseItemUpdateModeMap = ItemTypeMap<{
+    [itemId: string]: ChangesDeltaItemUpdateMode;
+}>;
+/**
+ * Converts a set of request columns to a set of columns of the item type by extracting the derived object key.
+ * Example:
+ * ```typescript
+ * const requestColumns = [
+ *      'serienummer',
+ *      {
+ *          materiaal: [
+ *              'displayname',
+ *              {
+ *                  creator: [
+ * 					    'displayname',
+ *                  ],
+ *              }
+ *          ],
+ *      },
+ *  ];
+ * ```
+ * Will turn into
+ * ```typescript
+ * [
+ *  'serienummer',
+ *  'materiaal',
+ * ]
+ * ```
+ */
+export type ConvertRequestToItemTypeColumnsIds<U extends ApiItemType, T extends ApiRequestColumnArray<U>> = {
+    -readonly [K in keyof T]: T[K] extends Record<string, unknown> ? keyof T[K] extends ItemTypeColumnId<U> ? keyof T[K] : never : T[K] extends ItemTypeColumnId<U> ? T[K] : never;
+};
+/**
+ * Transforms a set of request columns (which can contain derived column objects) to columns of the item
+ * by extracting the derived object key.
+ *
+ * This should *only* be used when you're transforming a set of columns to something that can *only* contain the item's
+ * columns such as a FieldMap or a ResponseColumnObject. If you use this in other situations you lose the derived column information
+ */
+export type RequestToItemColumns<U extends ApiItemType, T extends ApiRequestColumns<U>> = T extends ApiRequestColumnArray<U> ? ConvertRequestToItemTypeColumnsIds<U, T> extends ItemTypeColumnIds<U> ? ConvertRequestToItemTypeColumnsIds<U, T> : never : ItemTypeColumnIds<U>;
+export type RequestColumnsFieldMap<ItemTypeType extends ApiItemType, Columns extends ApiRequestColumns<ItemTypeType>> = FieldMap<ItemTypeType, RequestToItemColumns<ItemTypeType, Columns>>;
+export type RequestColumnsSignalFieldMap<ItemTypeType extends ApiItemType, Columns extends ApiRequestColumns<ItemTypeType>> = SignalFieldMap<ItemTypeType, RequestToItemColumns<ItemTypeType, Columns>>;
+export type HasFlagFn = (flag: RmLoginInfoFlag) => boolean;
+type JoinPath<Prefix extends string, Suffix extends string> = Prefix extends '' ? Suffix : `${Prefix}>${Suffix}`;
+type Add1<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends 2 ? 3 : T extends 3 ? 4 : T extends 4 ? 5 : never;
+/**
+ * Turns a set of request columns into a union of all possible string paths, excluding the root level.
+ * Example:
+ * ```typescript
+ * const requestColumns = [
+ *      'serienummer',
+ *      {
+ *          materiaal: [
+ *              'displayname',
+ *              {
+ *                  creator: [
+ *					    'displayname',
+ *                  ],
+ *              }
+ *          ],
+ *      },
+ *  ];
+ * ```
+ * Will turn into
+ * ```typescript
+ * 'materiaal>displayname' | 'materiaal>creator' | 'materiaal>creator>displayname'
+ * ```
+ */
+export type RequestColumnsToDerivedStringPaths<T, Prefix extends string = '', Depth extends number = 0> = Depth extends 5 ? any : T extends readonly (infer U)[] ? RequestColumnsToDerivedStringPaths<U, Prefix> : T extends string ? Prefix extends '' ? never : JoinPath<Prefix, T> : T extends Record<string, any> ? {
+    [K in keyof T]: (Prefix extends '' ? never : JoinPath<Prefix, K & string>) | RequestColumnsToDerivedStringPaths<T[K], JoinPath<Prefix, K & string>, Add1<Depth>>;
+}[keyof T] : never;
+/**
+ * Turns a set of request columns into a union of all possible path arrays, excluding the root level.
+ * Example:
+ * ```typescript
+ * const requestColumns = [
+ *      'serienummer',
+ *      {
+ *          materiaal: [
+ *              'displayname',
+ *              {
+ *                  creator: [
+ *					    'displayname',
+ *                  ],
+ *              }
+ *          ],
+ *      },
+ *  ];
+ * ```
+ * Will turn into
+ * ```typescript
+ * ['materiaal', 'displayname'] | ['materiaal', 'creator'] | ['materiaal', 'creator', 'displayname']
+ * ```
+ */
+export type RequestColumnsToDerivedArrayPaths<T, Prefix extends readonly string[] = [], Depth extends number = 0> = Depth extends 5 ? any : T extends readonly (infer U)[] ? (Prefix extends [] ? never : Prefix['length'] extends 1 ? never : Prefix) | RequestColumnsToDerivedArrayPaths<U, Prefix, Depth> : T extends string ? Prefix extends [] ? never : readonly [...Prefix, T] : T extends Record<string, any> ? (Prefix extends [] ? never : Prefix['length'] extends 1 ? never : Prefix) | {
+    [K in keyof T]: RequestColumnsToDerivedArrayPaths<T[K], [...Prefix, K & string], Add1<Depth>>;
+}[keyof T] : never;
+export type RequestParameters<ItemTypeType extends keyof BackendTypesRequestParameters> = {
+    [key in keyof BackendTypesRequestParameters[ItemTypeType]]: RequestParameterTypeToTsType<BackendTypesRequestParameters[ItemTypeType][key]>;
+};
+type RequestParameterTypeToTsType<RequestParameter> = (RequestParameter extends {
+    type: 'enum';
+    enum: string[];
+} ? RequestParameter['enum'][number] : RequestParameter extends {
+    type: keyof ApiEnumApiTypeToTsTypeMap;
+} ? ApiEnumApiTypeToTsTypeMap[RequestParameter['type']] : never) | (RequestParameter extends {
+    nullable: true;
+} ? null : never);
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@rentman/rm-core",
+  "version": "0.0.0-RM4-44763",
+  "description": "Rentman core functionalities",
+  "main": "./dist/rm-core.js",
+  "types": "./dist/types/src/index.d.ts",
+  "engines": {
+    "node": ">= 22.9.x <= 22.13.x",
+    "npm": ">= 10.8.x <= 10.9.x"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rentmanpublic/frontend-core"
+  },
+  "devDependencies": {
+    "@angular/core": "^20",
+    "@eslint/js": "^9.8.0",
+    "@rentman/backend-types": "4.796.0-60-gf11b0b4e33",
+    "@stylistic/eslint-plugin-ts": "^2.7.2",
+    "@types/eslint__js": "^8.42.3",
+    "clean-webpack-plugin": "^0.1.19",
+    "eslint": "^9.8.0",
+    "jsdom": "^26.1.0",
+    "moment": "^2.30.1",
+    "rxjs": "^7",
+    "terser-webpack-plugin": "^4.2.3",
+    "ts-loader": "^9.3.1",
+    "typescript": "5.5.4",
+    "typescript-eslint": "^8.4.0",
+    "vitest": "^3.2.3",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-merge": "^6.0.1"
+  },
+  "peerDependencies": {
+    "@angular/core": "^20",
+    "@rentman/backend-types": ">=4.786.0-47-g4a3c77a5db",
+    "moment": "^2.30.1",
+    "rxjs": "^7"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run bundle",
+    "bundle-dev": "webpack --config webpack.dev.js",
+    "bundle": "webpack --config webpack.prod.js",
+    "type-check": "tsc --noEmit -p ./tsconfig.json && tsc --noEmit -p ./tests/tsconfig.test.json",
+    "lint": "eslint src/**/*.ts tests/**/*.ts --quiet",
+    "test": "vitest --pool forks --poolOptions.forks.isolate",
+    "vitest-watch": "vitest --watch",
+    "coverage": "vitest --coverage"
+  },
+  "author": "Martijn Welker <martijn@rentman.nl>",
+  "license": "UNLICENSED"
+}

package/readme.md

@@ -0,0 +1,42 @@
+# Running a local test version
+1. Make changes
+2. run `npm run bundle-dev`
+3. copy `dist` folder to `<project>/node_modules/@rentman/rm-core/`
+4. Delete the Angular build cache (`.angular`) folder before rebuilding
+
+# Releasing
+
+## Production versions
+
+For stable releases to master:
+
+1. Go to [Release workflow](https://github.com/rentmanpublic/frontend-core/actions/workflows/release.yml)
+2. Click "Run workflow"
+3. Select version bump type:
+   - `major` – incompatible / breaking changes
+   - `minor` – adding functionality in a backward compatible manner
+   - `patch` – backward compatible changes / bug fixes
+4. Run the workflow
+
+This will publish to npm with the `latest` tag and create a git tag (e.g., `v59.4.0`).
+
+## Prereleases (Testing / PoC versions)
+
+For testing versions from feature branches:
+
+1. Go to [Prerelease workflow](https://github.com/rentmanpublic/frontend-core/actions/workflows/prerelease.yml)
+2. Click "Run workflow"
+3. Select the **branch** you want to release from
+4. Enter a prerelease identifier (e.g., `RM4-12345`, `beta`, `feature-x`)
+5. Run the workflow
+
+This will:
+- Create a version like `59.3.0-RM4-12345` (based on the last git tag)
+- Publish to npm with a custom tag (e.g., `RM4-12345`)
+- Commit and tag on your branch (e.g., `v59.3.0-RM4-12345`)
+- Auto-increment if tag exists: `59.3.0-RM4-12345-02`, `59.3.0-RM4-12345-03`, etc.
+
+To install a prerelease:
+```bash
+npm install @rentman/rm-core@RM4-12345
+```