@sdcorejs/angular 19.0.0-rc.1

package/pipes/src/safe-html.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SdSafeHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(html: string | number | undefined | null): import("@angular/platform-browser").SafeHtml | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdSafeHtmlPipe, "sdSafeHtml", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdSafeHtmlPipe>;
+}

package/pipes/src/time-different.pipe.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SdTimeDifferentPipe implements PipeTransform {
+    private maxSecond;
+    private maxMinute;
+    private maxHour;
+    private maxDay;
+    private maxMonth;
+    transform(value: any, format: string, different: 'second' | 'minute' | 'hour' | 'day' | 'month'): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTimeDifferentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdTimeDifferentPipe, "sdTimeDifferent", true>;
+}

package/public-api.d.ts

@@ -0,0 +1,10 @@
+import '@sdcorejs/angular/configurations';
+import '@sdcorejs/angular/utilities';
+import '@sdcorejs/angular/pipes';
+import '@sdcorejs/angular/directives';
+import '@sdcorejs/angular/services';
+import '@sdcorejs/angular/interceptors';
+import '@sdcorejs/angular/handlers';
+import '@sdcorejs/angular/components';
+import '@sdcorejs/angular/forms';
+import '@sdcorejs/angular/modules';

package/services/api/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/api.model';
+export * from './src/api.service';
+export * from './src/interceptors/api.interceptor';
+export * from './src/api.module';

package/services/api/src/api.model.d.ts

@@ -0,0 +1,36 @@
+import { HttpClient, HttpErrorResponse, HttpRequest, HttpResponse } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+import { SdCacheOption } from '@sdcorejs/angular/services/cache';
+export interface SdApiOption {
+    cacheOption?: SdCacheOption;
+    timeout?: number;
+    autoCache?: boolean;
+}
+type HttpGetOption = Parameters<HttpClient['get']>[1];
+export type SdGetOption = HttpGetOption & SdApiOption;
+type HttpPostOption = Parameters<HttpClient['post']>[2];
+export type SdPostOption = HttpPostOption & SdApiOption;
+type HttpPutOption = Parameters<HttpClient['put']>[2];
+export type SdPutOption = HttpPutOption & SdApiOption;
+type HttpDeleteOption = Parameters<HttpClient['delete']>[1];
+export type SdDeleteOption = HttpDeleteOption & SdApiOption;
+export interface SdApiHandler {
+    /** Danh sách host URL mà handler này sẽ xử lý */
+    hosts: string[];
+    /** Can thiệp request: gắn header, token, transform body... */
+    intercept?: (request: HttpRequest<any>) => HttpRequest<any>;
+    /** Hook chạy TRƯỚC khi gửi request (dùng để log, tracking...) */
+    beforeRemote?: (request: HttpRequest<any>) => void | Promise<void>;
+    /** Hook chạy SAU khi nhận response (xử lý lỗi, notify...) */
+    afterRemote?: (response: HttpResponse<any> | HttpErrorResponse | Error) => void | Promise<void>;
+    /** Transform response body thành kiểu dữ liệu mong muốn */
+    mapResponse?: <Tres = any, Tdata = any>(response: Tres) => Tdata;
+    /** Timeout tính bằng milliseconds. Mặc định: 30000 (30 giây) */
+    timeout?: number;
+}
+export interface ISdApiConfiguration {
+    handlers: SdApiHandler[];
+}
+export declare const SD_API_CONFIG: InjectionToken<ISdApiConfiguration>;
+export declare const SD_API_CONFIGURATION: InjectionToken<ISdApiConfiguration>;
+export {};

package/services/api/src/api.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SdApiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdApiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdApiModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdApiModule>;
+}

package/services/api/src/api.service.d.ts

@@ -0,0 +1,19 @@
+import { HttpClient } from '@angular/common/http';
+import { SdDeleteOption, SdGetOption, SdPostOption, SdPutOption } from './api.model';
+import * as i0 from "@angular/core";
+export declare class SdApiService {
+    #private;
+    constructor();
+    get http(): HttpClient;
+    get: <T = any>(url: string, option?: SdGetOption) => Promise<T>;
+    post: <T = any>(url: string, body?: any, option?: SdPostOption) => Promise<T>;
+    put: <T = any>(url: string, body?: any, option?: SdPutOption) => Promise<T>;
+    delete: <T = any>(url: string, option?: SdDeleteOption) => Promise<T>;
+    upload: (url: string, option?: {
+        extensions?: string[];
+        maxSizeInMb?: number;
+    }) => Promise<any>;
+    uploadFile: (url: string, file: File) => Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdApiService>;
+}

package/services/api/src/interceptors/api.interceptor.d.ts

@@ -0,0 +1,9 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SdHttpInterceptor implements HttpInterceptor {
+    #private;
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdHttpInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdHttpInterceptor>;
+}

package/services/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/cache.service';
+export * from './src/cache.model';

package/services/cache/src/cache.model.d.ts

@@ -0,0 +1,30 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+export interface SdCacheOption<T = any> {
+    type?: 'memory' | 'session' | 'local';
+    hours?: number;
+    default?: T;
+    args?: Record<string, any>;
+}
+export interface SdCache<T = any> {
+    get: () => T;
+    set: (data: T) => void;
+    has: () => boolean;
+    remove: () => void;
+    destroy: () => void;
+    observer: Observable<T | undefined>;
+    load: (callback: () => Promise<T>) => Promise<T>;
+}
+export interface ISdCacheConfiguration {
+    convertKey?: (key: string) => string;
+    set?: (key: string, value: {
+        data: any;
+        createdOn: Date;
+    }, option?: SdCacheOption) => Promise<void>;
+    get?: (key: string, option?: SdCacheOption) => Promise<{
+        data: any;
+        createdOn: Date;
+    }>;
+    remove?: (key: string, option?: SdCacheOption) => Promise<void>;
+}
+export declare const SD_CACHE_CONFIG: InjectionToken<ISdCacheConfiguration>;

package/services/cache/src/cache.service.d.ts

@@ -0,0 +1,9 @@
+import { SdCache, SdCacheOption } from './cache.model';
+import * as i0 from "@angular/core";
+export declare class SdCacheService {
+    #private;
+    constructor();
+    create<T = any>(key: string | object, option?: SdCacheOption<T>): SdCache<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdCacheService>;
+}

package/services/confirm/index.d.ts

@@ -0,0 +1 @@
+export * from './src/public-api';

package/services/confirm/src/lib/components/dialog-confirm/dialog-confirm.component.d.ts

@@ -0,0 +1,46 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { Color } from '@sdcorejs/utils/models';
+import * as i0 from "@angular/core";
+export interface DialogData {
+    icon?: string;
+    title?: string;
+    message?: string;
+    yesTitle?: string;
+    noTitle?: string;
+    yesButtonColor?: Color;
+    noButtonColor?: Color;
+    input?: {
+        placeholder?: string;
+        minlength?: number;
+        maxlength?: number;
+        required?: boolean;
+        defaultValue?: string;
+    };
+    date?: {
+        required?: boolean;
+        placeholder?: string;
+        defaultValue?: string | Date;
+        min?: string | Date;
+        max?: string | Date;
+    };
+    radio?: {
+        required?: boolean;
+        defaultValue?: string | number;
+        items: any[];
+        valueField: string;
+        displayField: string;
+        display?: 'row' | 'column';
+    };
+}
+export declare class DialogConfirmComponent {
+    dialogRef: MatDialogRef<DialogConfirmComponent>;
+    data: DialogData;
+    value: any;
+    required: boolean;
+    id: string;
+    constructor(dialogRef: MatDialogRef<DialogConfirmComponent>, data: DialogData);
+    onCancel: () => void;
+    onAccept: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogConfirmComponent, "sd-dialog-confirm", never, {}, {}, never, never, true, never>;
+}

package/services/confirm/src/lib/confirm.service.d.ts

@@ -0,0 +1,55 @@
+import { MatDialog } from '@angular/material/dialog';
+import { Color } from '@sdcorejs/utils/models';
+import * as i0 from "@angular/core";
+export declare class SdConfirmService {
+    #private;
+    private dialog;
+    constructor(dialog: MatDialog);
+    confirm: (message: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        width?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<unknown>;
+    withInput: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        maxlength?: number;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    withRadio: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string | number;
+        items: any[];
+        valueField: string;
+        displayField: string;
+        display?: "row" | "column";
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    withDate: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string | Date;
+        placeholder?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdConfirmService>;
+}

package/services/confirm/src/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/components/dialog-confirm/dialog-confirm.component';
+export * from './lib/confirm.service';

package/services/docx/index.d.ts

@@ -0,0 +1 @@
+export * from './src/public-api';

package/services/docx/src/lib/docx.model.d.ts

@@ -0,0 +1,9 @@
+export interface SdDocxConvertOptions {
+    validateFormat?: boolean;
+    validateSize?: boolean;
+    maxSizeInMb?: number;
+}
+export interface SdDocxConvertResult {
+    html: string;
+    messages: string[];
+}

package/services/docx/src/lib/docx.service.d.ts

@@ -0,0 +1,15 @@
+import { SdNotifyService } from '@sdcorejs/angular/services/notify';
+import { SdLoadingService } from '@sdcorejs/angular/services/loading';
+import { SdDocxConvertOptions, SdDocxConvertResult } from './docx.model';
+import * as i0 from "@angular/core";
+export declare class SdDocxService {
+    #private;
+    private notifyService;
+    private loadingService;
+    constructor(notifyService: SdNotifyService, loadingService: SdLoadingService);
+    open(options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
+    convertToHtml(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
+    convertToHtmlString(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdDocxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdDocxService>;
+}

package/services/docx/src/lib/pandoc-core.d.ts

@@ -0,0 +1,11 @@
+export interface PandocConvertResult {
+    stdout: string;
+    stderr: string;
+    warnings: any[];
+    files: Record<string, any>;
+    mediaFiles: Record<string, any>;
+}
+export interface PandocInstance {
+    convert(options: Record<string, any>, stdin: string | null, files: Record<string, Blob | string>): Promise<PandocConvertResult>;
+}
+export declare function createPandocInstance(wasmBinary: ArrayBuffer): Promise<PandocInstance>;

package/services/docx/src/public-api.d.ts

@@ -0,0 +1,2 @@
+export { SdDocxService } from './lib/docx.service';
+export type { SdDocxConvertOptions, SdDocxConvertResult } from './lib/docx.model';

package/services/excel/index.d.ts

@@ -0,0 +1 @@
+export * from './src/public-api';

package/services/excel/src/lib/excel.model.d.ts

@@ -0,0 +1,31 @@
+export interface SdExcelTemplate {
+    fileName?: string;
+    columns: SdExcelTemplateColumn[];
+    sheets?: SdExcelSheet[];
+}
+export interface SdExcelColumn {
+    field: string;
+    title: string;
+    description?: string;
+    width?: string;
+}
+export interface SdExcelTemplateColumn extends SdExcelColumn {
+    required?: boolean;
+    color?: string;
+    fontColor?: string;
+    fill?: string;
+}
+export interface SdExcelSheet<T = any> {
+    name: string;
+    items: T[];
+    headers: {
+        value: Extract<keyof T, string>;
+        display: string;
+    }[];
+}
+export interface SdExcelExportOption<T = any> {
+    columns: SdExcelTemplateColumn[];
+    items: T[];
+    fileName?: string;
+    sheets?: SdExcelSheet[];
+}

package/services/excel/src/lib/excel.service.d.ts

@@ -0,0 +1,19 @@
+import { SdExcelExportOption, SdExcelTemplate } from './excel.model';
+import * as i0 from "@angular/core";
+export declare class SdExcelService {
+    #private;
+    constructor();
+    generateTemplate: (template: SdExcelTemplate) => Promise<void>;
+    exportCSV: (option: SdExcelExportOption) => Promise<void>;
+    export: (option: SdExcelExportOption) => Promise<void>;
+    upload: () => Promise<{
+        items: Record<string, any>[];
+        file: File | null;
+    }>;
+    parse: (file: File) => Promise<{
+        items: Record<string, any>[];
+        file: File | null;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdExcelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdExcelService>;
+}

package/services/excel/src/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/excel.model';
+export * from './lib/excel.service';

package/services/index.d.ts

@@ -0,0 +1,8 @@
+export * from '@sdcorejs/angular/services/cache';
+export * from '@sdcorejs/angular/services/storage';
+export * from '@sdcorejs/angular/services/notify';
+export * from '@sdcorejs/angular/services/confirm';
+export * from '@sdcorejs/angular/services/api';
+export * from '@sdcorejs/angular/services/loading';
+export * from '@sdcorejs/angular/services/excel';
+export * from '@sdcorejs/angular/services/docx';

package/services/license/index.d.ts

@@ -0,0 +1 @@
+export * from './src/license.service';

package/services/license/src/license.service.d.ts

@@ -0,0 +1,10 @@
+import { ISdCoreConfiguration } from '@sdcorejs/angular/configurations';
+import * as i0 from "@angular/core";
+export declare class SdLicenseService {
+    #private;
+    private readonly coreConfiguration;
+    constructor(coreConfiguration: ISdCoreConfiguration | undefined);
+    enforceLicense: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLicenseService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLicenseService>;
+}

package/services/loading/index.d.ts

@@ -0,0 +1 @@
+export * from './src/loading.service';

package/services/loading/src/loading.service.d.ts

@@ -0,0 +1,14 @@
+import { RendererFactory2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SdLoadingService {
+    #private;
+    private loadingId;
+    private renderer;
+    private loadingMap;
+    constructor(rendererFactory: RendererFactory2);
+    start: (element?: string) => void;
+    isLoading: (element?: string) => boolean | null;
+    stop: (element?: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLoadingService>;
+}

package/services/notify/index.d.ts

@@ -0,0 +1,2 @@
+export { type NotifyOption as SdNotifyOption } from './src/notify.model';
+export * from './src/notify.service';

package/services/notify/src/components/toast/toast.component.d.ts

@@ -0,0 +1,28 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { ToastData } from '../../notify.model';
+import { SdNotifyService } from '../../notify.service';
+import * as i0 from "@angular/core";
+export declare class ToastComponent implements OnInit, OnDestroy {
+    private notifyService;
+    data: ToastData;
+    isExpanded: import("@angular/core").WritableSignal<boolean>;
+    readonly MAX_SHOW = 2;
+    private timer;
+    private start;
+    private remaining;
+    constructor(notifyService: SdNotifyService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    pauseTimer(): void;
+    resumeTimer(): void;
+    close(): void;
+    onActionClick(): void;
+    toggleExpand(): void;
+    get isMultiMessage(): boolean;
+    get messages(): string[];
+    get displayMessages(): string[];
+    get restCount(): number;
+    get hasMore(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "toast", never, { "data": { "alias": "data"; "required": true; }; }, {}, never, never, true, never>;
+}

package/services/notify/src/components/toast-container.component.d.ts

@@ -0,0 +1,8 @@
+import { WritableSignal } from '@angular/core';
+import { ToastData } from '../notify.model';
+import * as i0 from "@angular/core";
+export declare class ToastContainerComponent {
+    toasts: WritableSignal<ToastData[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastContainerComponent, "toast-container", never, {}, {}, never, never, true, never>;
+}

package/services/notify/src/notify.model.d.ts

@@ -0,0 +1,16 @@
+export type ToastType = 'success' | 'info' | 'warning' | 'error';
+export interface ToastData {
+    id: string;
+    type: ToastType;
+    title?: string;
+    message: string | string[];
+    duration: number;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+export interface NotifyOption {
+    duration?: number;
+    title?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+}

package/services/notify/src/notify.service.d.ts

@@ -0,0 +1,20 @@
+import { ApplicationRef, EnvironmentInjector } from '@angular/core';
+import { NotifyOption, ToastData, ToastType } from './notify.model';
+import * as i0 from "@angular/core";
+export declare class SdNotifyService {
+    #private;
+    private appRef;
+    private injector;
+    private document;
+    readonly toasts: import("@angular/core").WritableSignal<ToastData[]>;
+    constructor(appRef: ApplicationRef, injector: EnvironmentInjector, document: Document);
+    success(message: string, option?: NotifyOption): void;
+    info(message: string, option?: NotifyOption): void;
+    warning(message: string | string[], option?: NotifyOption): void;
+    error(message: string | string[], option?: NotifyOption): void;
+    remove(id: string): void;
+    clearAll(): void;
+    clearByType(type: ToastType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdNotifyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdNotifyService>;
+}

package/services/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/storage.model';
+export * from './src/storage.service';

package/services/storage/src/storage.model.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+export interface SdStorageOption<T = any> {
+    type?: 'session';
+    default?: T;
+    args?: Record<string, any>;
+}
+export interface SdStorage<T = any> {
+    get: () => T;
+    set: (data: T) => void;
+    setSilent: (data: T) => void;
+    has: () => boolean;
+    remove: () => void;
+    subject: BehaviorSubject<T>;
+    observer: Observable<T>;
+}
+export interface ISdStorageConfiguration {
+    key?: (key: string) => string;
+}
+export declare const SD_STORAGE_CONFIG: InjectionToken<ISdStorageConfiguration>;

package/services/storage/src/storage.service.d.ts

@@ -0,0 +1,10 @@
+import { ISdStorageConfiguration, SdStorage, SdStorageOption } from './storage.model';
+import * as i0 from "@angular/core";
+export declare class SdStorageService {
+    #private;
+    private configuration;
+    constructor(configuration: ISdStorageConfiguration);
+    create<T = any>(key: string | object, option?: SdStorageOption<T>): SdStorage<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdStorageService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdStorageService>;
+}

package/utilities/data-state/index.d.ts

@@ -0,0 +1 @@
+export * from './src/data-state';

package/utilities/data-state/src/data-state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Serialize a value for the `data-value` attribute consumed by QA automation.
+ *
+ * null/undefined/empty-string → ''.
+ * Date → ISO string.
+ * Array / object → JSON.stringify, '' on failure (circular refs).
+ * Primitives → String().
+ */
+export declare function sdSerializeDataValue(value: unknown): string;
+/** True when the value should drive `data-empty="true"` on a form control. */
+export declare function sdIsEmpty(value: unknown): boolean;

package/utilities/extensions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './src/array.extension';
+export * from './src/string.extension';
+export * from './src/number.extension';
+export * from './src/date.extension';
+export * from './src/utility.extension';
+export * from './src/color.extension';

package/utilities/extensions/src/array.extension.d.ts

@@ -0,0 +1 @@
+export { ArrayUtilities } from '@sdcorejs/utils/fns';

package/utilities/extensions/src/color.extension.d.ts

@@ -0,0 +1,5 @@
+export { ColorUtilities } from '@sdcorejs/utils/fns';
+/** @deprecated Use {@link ColorUtilities.hslToHex} from `@sdcorejs/utils/fns` instead */
+export declare const hslToHex: (h: number, s: number, l: number) => string;
+/** @deprecated Use {@link ColorUtilities.rgbToHex} from `@sdcorejs/utils/fns` instead */
+export declare const rgbToHex: (r: number, g: number, b: number) => string;

package/utilities/extensions/src/date.extension.d.ts

@@ -0,0 +1 @@
+export { DateUtilities } from '@sdcorejs/utils/fns';

package/utilities/extensions/src/number.extension.d.ts

@@ -0,0 +1 @@
+export { NumberUtilities } from '@sdcorejs/utils/fns';

package/utilities/extensions/src/string.extension.d.ts

@@ -0,0 +1,50 @@
+import { ValidationUtilities } from '@sdcorejs/utils/fns';
+export { ValidationUtilities };
+export declare const StringUtilities: {
+    /** @deprecated Use REGEX_VN_PHONE instead */
+    REGEX_PHONE_VN: string;
+    /** @deprecated Use REGEX_VN_ID instead */
+    REGEX_IDVN: string;
+    /** @deprecated Use REGEX_VN_ID_OR_PASSPORT instead */
+    REGEX_IDVN_OR_PASSPORT: string;
+    /** @deprecated Use {@link ValidationUtilities.isEmail} instead */
+    isValidEmail: (value: any) => boolean;
+    /** @deprecated Use {@link ValidationUtilities.isPhone} instead */
+    isValidPhone: (value: any) => boolean;
+    /** @deprecated Use {@link ValidationUtilities.isCode} instead */
+    isValidCode: (value: any) => boolean;
+    REGEX_EMAIL: string;
+    REGEX_PHONE: string;
+    REGEX_VN_PHONE: string;
+    REGEX_VN_ID: string;
+    REGEX_PASSPORT: string;
+    REGEX_VN_ID_OR_PASSPORT: string;
+    REGEX_TIME: string;
+    REGEX_URL: string;
+    REGEX_DOMAIN: string;
+    REGEX_IPV4: string;
+    REGEX_IPV6: string;
+    REGEX_IMAGE_URL: string;
+    REGEX_SLUG: string;
+    REGEX_NUMBER: string;
+    REGEX_INTEGER: string;
+    REGEX_DECIMAL: string;
+    REGEX_POSITIVE_NUMBER: string;
+    REGEX_UUID: string;
+    REGEX_CODE_16: string;
+    REGEX_CODE_32: string;
+    REGEX_HEX_COLOR: string;
+    REGEX_BASE64: string;
+    changeAliasLowerCase: (alias: any) => string;
+    aliasIncludes: (alias: any, searchText: any) => boolean;
+    format: (template: string, ...arr: any[]) => string;
+    templateToDisplay: (template: string, entity: Record<string, any>) => string;
+    parseExpression: (template: string, entity: Record<string, any>) => any;
+    encrypt: (obj: any) => string;
+    decrypt: (encripted: string) => any;
+    isNullOrEmpty: (value: any) => boolean;
+    isNullOrWhiteSpace: (value: any) => boolean;
+    convertToSnakeCaseCode: (name: string) => string;
+    generateUniqueCode: (name: string, existingCodes: string[]) => string;
+    sha256: (input: string) => Promise<string>;
+};