@native-systems/utility 1.2.0 → 2.0.0

package/dist/index.d.ts

@@ -664,7 +664,7 @@ declare module "@native-systems/utility" {
 }
 
 declare module "@native-systems/utility" {
-    namespace Native {
+    namespace native {
         type Error = ErrorConstructor & {
             status: number;
             message: string;
@@ -675,11 +675,54 @@ declare module "@native-systems/utility" {
         }
         export { Error, ErrorResponse };
     }
-    export type { Native };
+    export type { native };
 }
 
 declare module "@native-systems/utility" {
-    import { Native } from "@/types";
+    type Paginated<T> = {
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+        totalPages: number;
+        data: T;
+    };
+    export type { Paginated };
+}
+
+declare module "@native-systems/utility" {
+    type CancelableComponent<T> = {
+        value: T;
+        cancel: () => void;
+    };
+    export type { CancelableComponent };
+}
+
+declare module "@native-systems/utility" {
+    type CRUDCompontent<T, U = T, V = U> = {
+        value: T;
+        add: (value: U) => void;
+        delete: (id: string) => void;
+        update: (id: string, value: V) => void;
+    };
+    export type { CRUDCompontent };
+}
+
+declare module "@native-systems/utility" {
+    import { Dispatch, SetStateAction } from "react";
+    type UseStateComponent<T, U = T> = {
+        current: T;
+        update: (value: U) => void;
+    };
+    /** Same grouping type as the UseStateComponent type, with the difference,
+     * that here the update function is directly linked with the useState variable. */
+    type DirectUseStateComponent<T> = {
+        current: T;
+        update: Dispatch<SetStateAction<T>>;
+    };
+    export type { DirectUseStateComponent, UseStateComponent };
+}
+
+declare module "@native-systems/utility" {
+    import { native } from "@/types";
     class HttpHandler {
         /**
          * Http request response handler, which checks if the given response is in status range 'ok'.
@@ -688,17 +731,17 @@ declare module "@native-systems/utility" {
          * This means, that the reason of the error is not a network error for example.
          * @param response {Response} The raw response data from the server, which could also be a Native.Error.
          * @returns {<T>} The expected data resource, if the status of the request is 'ok'.
-         * @throws {Native.ErrorResponse} A modified version of the default Response object, to be able to detect if the error response is of the expected type.
+         * @throws {native.ErrorResponse} A modified version of the default Response object, to be able to detect if the error response is of the expected type.
          */
         static response<T>(response: Response): Promise<T>;
         /**
          * Http request error handler, that always returns the correct error object.
          * Either fast forwards the already correctly formatted naive error or set up a new native error, based on the provided info.
          * The generic typing is just used to prevent type errors.
-         * @param response {Response | Native.ErrorResponse} The Response object that errored. Can either be a default object, or the modified native version.
-         * @throws {Native.Error} Always throws an error, which is always of this type.
+         * @param response {Response | native.ErrorResponse} The Response object that errored. Can either be a default object, or the modified native version.
+         * @throws {native.Error} Always throws an error, which is always of this type.
          */
-        static error<T>(response: Response | Native.ErrorResponse): Promise<T>;
+        static error<T>(response: Response | native.ErrorResponse): Promise<T>;
     }
     export { HttpHandler };
 }
@@ -722,3 +765,106 @@ declare module "@native-systems/utility" {
     }
     export { CookieHelper };
 }
+
+declare module "@native-systems/utility" {
+    export function parseTemplate(template: string): {
+        expand: (context: Record<string, unknown>) => string;
+    };
+}
+
+declare module "@native-systems/utility" {
+    export type PatternView = Record<string | number, any>;
+    export type CompileFn = (source?: string | null, view?: PatternView) => string;
+    export interface IPatternCompiler {
+        compile: CompileFn;
+        keyToTemplate(key: string): string;
+    }
+}
+
+declare module "@native-systems/utility" {
+    import Handlebars from "handlebars";
+    export class PatternCompiler implements IPatternCompiler {
+        private defaultView;
+        private handlebars;
+        constructor(defaultView: PatternView, installPlugins: (handlebars: typeof Handlebars) => void);
+        compile(source?: string | null, partialView?: PatternView): string;
+        static keyToTemplate(key: string): string;
+        keyToTemplate(key: string): string;
+    }
+}
+
+declare module "@native-systems/utility" {
+    export type CompilerPlugin<T> = (handlebars: typeof Handlebars, data: T) => void;
+}
+
+declare module "@native-systems/utility" {
+    export const eqPlugin: CompilerPlugin<never>;
+}
+
+declare module "@native-systems/utility" {
+    export const markdownPlugin: CompilerPlugin<never>;
+}
+
+declare module "@native-systems/utility" {
+    export const stringPlugin: CompilerPlugin<never>;
+}
+
+declare module "@native-systems/utility" {
+    export class DateFormatter {
+        /**
+         * Formats a date with time in German format
+         * @param date Date object or date string to format
+         * @returns Formatted date string
+         * @example
+         * // Returns "14.08.2025, 15:30"
+         * DateFormatter.format(new Date('2025-08-14T15:30:00'))
+         */
+        static format(date: Date | string): string;
+        /**
+         * Formats a date in formal German format without time
+         * @param date Date object or date string to format
+         * @returns Formatted date string
+         * @example
+         * // Returns "14.08.2025"
+         * DateFormatter.formatFormal(new Date('2025-08-14T15:30:00'))
+         */
+        static formatFormal(date: Date | string): string;
+        /**
+         * Formats a date in German format with full month name
+         * @param date Date object or date string to format
+         * @returns Formatted date string
+         * @example
+         * // Returns "14. August 2025"
+         * DateFormatter.formatMini(new Date('2025-08-14T15:30:00'))
+         */
+        static formatMini(date: Date | string): string;
+        static getZoneAdjustedWeekday: (dateString: string, options: {
+            timezone: string;
+            locale: string | undefined;
+        }) => string;
+        static getZoneAdjustedDate: (dateString: string, options: {
+            timezone: string;
+            locale: string | undefined;
+        }) => string;
+        static getZoneAdjustedTime: (dateString: string, options: {
+            timezone: string;
+            locale: string | undefined;
+        }) => string;
+    }
+}
+
+declare module "@native-systems/utility" {
+    export type UserTimezone = {
+        timezone: string;
+        locale: string;
+    };
+    export const timezonePlugin: CompilerPlugin<UserTimezone>;
+}
+
+declare module "@native-systems/utility" {
+    export const urlPlugin: CompilerPlugin<never>;
+}
+
+declare module "@native-systems/utility" {
+    export const userTimezonePlugin: CompilerPlugin<UserTimezone>;
+}