@bootkit/ng0 0.0.0-alpha.5 → 0.0.0-alpha.50

package/routing/index.d.ts

@@ -0,0 +1,124 @@
+import { Observable } from 'rxjs';
+import { ActivatedRouteSnapshot, UrlTree, RouterStateSnapshot, Route as Route$1 } from '@angular/router';
+import { ClaimLike } from '@bootkit/ng0/common';
+import * as i0 from '@angular/core';
+
+/**
+ * A function that resolves a title from the route and router state
+ */
+type RouteTitleResolver = (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => string;
+/**
+ * A router link value.
+ */
+type RouterLinkValue = any[] | string | UrlTree | null | undefined;
+/**
+ * A function that resolves a router link.
+ * @param route The activated route snapshot
+ * @param state The router state snapshot
+ * @returns The resolved link (RouteDataLink)
+ */
+type RouterLinkValueResolver = (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => RouterLinkValue;
+/**
+ * A function that resolves a meta description.
+ * @param route The activated route snapshot
+ * @param state The router state snapshot
+ * @returns The resolved meta description string
+ */
+type RouteMetaDescriptionResolver = (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => string;
+/**
+ * A function that resolves meta tags from the route and router state
+ */
+type RouteMetaTagResolver = (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => {
+    [metaTagName: string]: string;
+};
+/**
+ * Route data
+ */
+interface RouteData {
+    /**
+     * The title of the route, or a function that resolves the title.
+     */
+    title?: string | RouteTitleResolver;
+    /**
+     * A Router link defined for the route.
+     */
+    link?: RouterLinkValue | RouterLinkValueResolver;
+    /**
+     * linkTarget
+     */
+    linkTarget?: '_self' | '_blank' | '_parent' | '_top';
+    /**
+     * meta
+     */
+    meta?: string | RouteMetaTagResolver | RouteMetaDescriptionResolver;
+    /**
+     * Route security claim.
+     */
+    claim?: ClaimLike;
+    /**
+     * Route childreen.
+     */
+    children?: RouteData[];
+    [key: string]: any;
+}
+/**
+ * Router Activated Route Snapshot.
+ * Represents the state of an activated route in the router.
+ */
+interface RouterActivatedRouteSnapshot {
+    /**
+     * The original ActivatedRouteSnapshot
+     */
+    activatedRoute: ActivatedRouteSnapshot;
+    /**
+     * Resolved title, if any
+     */
+    title?: string;
+    /**
+     * Resolved link, if any
+     */
+    link: RouterLinkValue;
+    /**
+     * Children routes
+     */
+    children: RouterActivatedRouteSnapshot[];
+}
+/**
+ * Extended Angular Route interface with additional data property.
+ */
+interface Route extends Route$1 {
+    children?: Routes;
+    data?: RouteData;
+}
+type Routes = Route[];
+
+/**
+ * Service to interact with Angular Router.
+ */
+declare class RouterService {
+    private readonly _router;
+    /**
+     * Get activated route tree.
+     * @param outlets List of outlets to include, default is ['primary']
+     * @returns Observable of the activated route tree
+     */
+    getActivatedRouteTree(outlets?: string[]): Observable<RouterActivatedRouteSnapshot>;
+    /**
+     * Get activated routes as a flat array from root to the deepest child for a specific outlet.
+     * @param outlet The outlet to include, default is 'primary'
+     * @returns Observable of the activated routes array
+     */
+    getActivatedRoutes(outlet?: string): Observable<RouterActivatedRouteSnapshot[]>;
+    /**
+     * Map a route to RouterRouteSnapshot
+     * @param route The route to map
+     * @param outlets The outlets to include
+     * @returns The mapped RouterRouteSnapshot
+     */
+    private _mapRoute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouterService>;
+}
+
+export { RouterService };
+export type { Route, RouteData, RouteMetaDescriptionResolver, RouteMetaTagResolver, RouteTitleResolver, RouterActivatedRouteSnapshot, RouterLinkValue, RouterLinkValueResolver, Routes };

package/security/index.d.ts

@@ -1,31 +1,55 @@
-import { ClaimLike } from '@bootkit/ng0/common';
 import * as i0 from '@angular/core';
 import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { ClaimLike, UserCondition } from '@bootkit/ng0/common';
 
 /** User */
 declare class User {
-    readonly claims: string[];
+    readonly claims: i0.WritableSignal<string[]>;
     constructor(claims: string[]);
-    hasClaims(claims: string[]): boolean;
+    addClaim(claim: string): boolean;
+    removeClaim(claim: string): boolean;
+    hasAllClaims(claims: string[]): boolean;
     hasAnyClaim(claims: string[]): boolean;
     hasClaim(claim: ClaimLike): boolean;
 }
 
+/**
+ * Service to manage the current user state.
+ */
 declare class UserStore<U extends User = User> {
     readonly user: i0.WritableSignal<U | null | undefined>;
-    constructor();
+    /**
+     * Check if the given condition is met by the current user.
+     * If there is no user, only 'false' condition is met.
+     * If there is a user, 'true' conditions and claims will be checked.
+     * @param condition The user condition to check
+     * @returns Whether the condition is met
+     */
+    checkCondition(condition: UserCondition): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<UserStore<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<UserStore<any>>;
 }
 
-declare class UserDirective {
-    claim: i0.InputSignal<ClaimLike | null | undefined>;
+/**
+ * @deprecated use *ng0User instead
+ */
+declare class ClaimDirective {
     private _viewCreated;
-    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, userStore: UserStore);
-    static ɵfac: i0.ɵɵFactoryDeclaration<UserDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<UserDirective, "[ng0Claim]", ["ng0Claim"], { "claim": { "alias": "ng0Claim"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    private _templateRef;
+    private _viewContainer;
+    private _userStore;
+    /**
+     * Claim to check
+     */
+    readonly claim: i0.InputSignal<ClaimLike | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClaimDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClaimDirective, "[ng0Claim]", ["ng0Claim"], { "claim": { "alias": "ng0Claim"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * @deprecated use *ng0User directive instead
+ */
 declare class GuestUserDirective {
     private _created;
     constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, userStore: UserStore);
@@ -35,8 +59,49 @@ declare class GuestUserDirective {
 
 declare class SecurityModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<SecurityModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<SecurityModule, never, [typeof UserDirective, typeof GuestUserDirective], [typeof UserDirective, typeof GuestUserDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SecurityModule, never, [typeof ClaimDirective, typeof GuestUserDirective], [typeof ClaimDirective, typeof GuestUserDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<SecurityModule>;
 }
 
-export { GuestUserDirective, SecurityModule, User, UserDirective, UserStore };
+/**
+ * Directive to conditionally display content based on user claims or conditions.
+ * If there is no condition provided, the content is always shown.
+ * If a condition is provided, it checks against the current user.
+ * @example
+ * ```html
+ * <ng-container *ng0User="true">
+ *  This content is shown only if there is a logged-in user, regardless of claims.
+ * </ng-container>
+ * <ng-container *ng0User="false">
+ * This content is shown only if there is no logged-in user.
+ * </ng-container>
+ * <ng-container *ng0User="'admin'">
+ * This content is shown only if the user has the 'admin' claim.
+ * </ng-container>
+ * <ng-container *ng0User="{ all: ['read', 'write'] }">
+ * This content is shown only if the user has both 'read' and 'write' claims.
+ * </ng-container>
+ * <ng-container *ng0User="{ any: ['editor', 'contributor'] }">
+ * This content is shown if the user has either 'editor' or 'contributor' claims.
+ * </ng-container>
+ * <ng-container *ng0User="null">
+ * This content is always shown, regardless of user state.
+ * </ng-container>
+ * ```
+ */
+declare class UserDirective {
+    private _viewCreated;
+    private readonly _templateRef;
+    private readonly _viewContainer;
+    private readonly _userStore;
+    /**
+     * Show condition to check
+     *
+     */
+    readonly condition: i0.InputSignal<UserCondition | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UserDirective, "[ng0User]", ["ng0User"], { "condition": { "alias": "ng0User"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ClaimDirective, GuestUserDirective, SecurityModule, User, UserDirective, UserStore };

package/utils/index.d.ts

@@ -0,0 +1,63 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Easing function type definition.
+ */
+type EasingFn = (t: number) => number;
+/**
+ * A counter that animates a numeric value from a start to an end value over a specified duration using an easing function.
+ */
+declare class Counter {
+    readonly from: number;
+    readonly to: number;
+    readonly duration: number;
+    private _subscription?;
+    readonly value: _angular_core.WritableSignal<number>;
+    readonly running: _angular_core.WritableSignal<boolean>;
+    readonly easing: EasingFn;
+    constructor(from: number, to: number, duration?: number, easing?: EasingFn, currentValue?: number);
+    /**
+     * Resets the counter and starts it.
+     * This method should be called in a browser environment.
+     * @returns void
+     */
+    start(): void;
+    /**
+     * Stops the counter animation.
+     */
+    stop(): void;
+}
+/**
+ * A collection of common easing functions for animations.
+ */
+declare const easingFunctions: {
+    linear: (t: number) => number;
+    easeIn: (t: number) => number;
+    easeOut: (t: number) => number;
+    easeInOut: (t: number) => number;
+    smooth: (t: number) => number;
+};
+
+declare class StyleManager {
+    private readonly _rendererFactory;
+    private readonly _document;
+    private readonly _renderer;
+    private readonly _loadedStyles;
+    /**
+     * Loads a CSS
+     * @param url
+     * @returns Promise<HTMLLinkElement>
+     */
+    load(url: string): Promise<HTMLLinkElement>;
+    /**
+     * Unloads a CSS from the DOM
+     * @param url
+     * @returns void
+     */
+    unload(url: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StyleManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StyleManager>;
+}
+
+export { Counter, StyleManager, easingFunctions };
+export type { EasingFn };