@ethlete/core 4.4.1 → 4.5.1

package/lib/directives/animated-lifecycle/animated-lifecycle.directive.d.ts

@@ -14,7 +14,10 @@ export declare class AnimatedLifecycleDirective implements AfterViewInit {
     get state(): AnimatedLifecycleState;
     readonly hostClassBindings: {
         remove: (...tokens: string[]) => void;
+        removeMany: (tokens: string[]) => void;
         has: (token: string) => boolean;
+        push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
     };
     ngAfterViewInit(): void;
     enter(config?: {

package/lib/props/create-prop-handlers.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef } from '@angular/core';
+export declare const createPropHandlers: () => {
+    classes: {
+        remove: (...tokens: string[]) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (token: string) => boolean;
+        push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    attributes: {
+        remove: (...tokens: string[]) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (token: string) => boolean;
+        push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    styles: {
+        remove: (...tokens: string[]) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (token: string) => boolean;
+        push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    id: string;
+    elementRef: ElementRef<HTMLElement>;
+};
+export type PropHandlers = ReturnType<typeof createPropHandlers>;

package/lib/props/create-props.d.ts

@@ -0,0 +1,54 @@
+import { Signal } from '@angular/core';
+import { PropHandlers } from './create-prop-handlers';
+export type Props = Readonly<{
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElements;
+}>;
+export interface PropsAttachedElements {
+    first: Signal<HTMLElement | null>;
+    firstId: Signal<string | null>;
+    get(id: string): HTMLElement | null;
+}
+export interface PropsAttachedElementsInternal extends PropsAttachedElements {
+    has: (id: string) => boolean;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+}
+export interface PropsInternal {
+    single: boolean;
+    name: string;
+    bindId: boolean;
+    attached: Signal<boolean>;
+    attachedElements: PropsAttachedElementsInternal;
+    classBindings: Record<string, Signal<unknown>> | null;
+    attributeBindings: Record<string, Signal<unknown>> | null;
+    styleBindings: Record<string, Signal<unknown>> | null;
+    staticClassBindings: string[] | null;
+    staticAttributeBindings: Record<string, unknown> | null;
+    staticStyleBindings: Record<string, unknown> | null;
+    attachEventListeners: ((context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void) | null;
+}
+export interface CreatePropsOptions {
+    name: string;
+    bindId?: boolean;
+    single?: boolean;
+    classes?: Record<string, Signal<unknown>>;
+    attributes?: Record<string, Signal<unknown>>;
+    styles?: Record<string, Signal<unknown>>;
+    staticClasses?: string[];
+    staticAttributes?: Record<string, unknown>;
+    staticStyles?: Record<string, unknown>;
+    listeners?: (context: {
+        on: HTMLElement['addEventListener'];
+        element: HTMLElement;
+    }) => void;
+}
+export declare const createProps: (props: CreatePropsOptions) => Props;
+export interface HostProps {
+    props: Props;
+    handlers: PropHandlers;
+}
+export declare const createHostProps: (props: CreatePropsOptions) => HostProps;

package/lib/props/create-setup.d.ts

@@ -0,0 +1,4 @@
+export declare const createSetup: <T extends Record<string, unknown>>(config: {
+    setupFn: (params: T) => void;
+    this: ThisType<unknown>;
+}) => (params: T) => void;

package/lib/props/dependency-stash.d.ts

@@ -0,0 +1,11 @@
+import { Signal, WritableSignal } from '@angular/core';
+export declare const createDependencyStash: <T extends Record<string, WritableSignal<unknown>>>(stash: T) => T & {
+    provideSignal: <K extends keyof T>(data: {
+        signal: Signal<ReturnType<T[K]>>;
+        for: K;
+    }) => void;
+    provideValue: <K_1 extends keyof T>(data: {
+        value: ReturnType<T[K_1]>;
+        for: K_1;
+    }) => void;
+};

package/lib/props/element-dictionary.d.ts

@@ -0,0 +1,11 @@
+export declare const createElementDictionary: () => {
+    ids: import("@angular/core").Signal<string[]>;
+    elements: import("@angular/core").Signal<HTMLElement[]>;
+    has: (id: string) => boolean;
+    get: (id: string) => HTMLElement | null;
+    push: (id: string, element: HTMLElement) => void;
+    remove: (id: string) => void;
+    isEmpty: import("@angular/core").Signal<boolean>;
+    firstElement: import("@angular/core").Signal<HTMLElement | null>;
+    firstId: import("@angular/core").Signal<string | null>;
+};

package/lib/props/index.d.ts

@@ -0,0 +1,8 @@
+export * from './create-prop-handlers';
+export * from './create-props';
+export * from './create-setup';
+export * from './dependency-stash';
+export * from './element-dictionary';
+export * from './props-binding';
+export * from './props.directive';
+export * from './template-input';

package/lib/props/props-binding.d.ts

@@ -0,0 +1,12 @@
+import { PropHandlers } from './create-prop-handlers';
+import { Props, PropsInternal } from './create-props';
+export interface BindPropsOptions {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+}
+export declare const bindProps: (config: BindPropsOptions) => void;
+export interface UnbindPropsOptions {
+    props: Props | PropsInternal;
+    handlers: PropHandlers;
+}
+export declare const unbindProps: (config: UnbindPropsOptions) => void;

package/lib/props/props.directive.d.ts

@@ -0,0 +1,38 @@
+import { DestroyRef } from '@angular/core';
+import { PropsInternal } from './create-props';
+import * as i0 from "@angular/core";
+export declare class PropsDirective {
+    destroyRef: DestroyRef;
+    props: import("@angular/core").InputSignal<PropsInternal, Readonly<{
+        attached: import("@angular/core").Signal<boolean>;
+        attachedElements: import("./create-props").PropsAttachedElements;
+    }>>;
+    propHandlers: {
+        classes: {
+            remove: (...tokens: string[]) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (token: string) => boolean;
+            push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+            pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+        };
+        attributes: {
+            remove: (...tokens: string[]) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (token: string) => boolean;
+            push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+            pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+        };
+        styles: {
+            remove: (...tokens: string[]) => void;
+            removeMany: (tokens: string[]) => void;
+            has: (token: string) => boolean;
+            push: (tokenString: string, signal: import("@angular/core").Signal<unknown>) => void;
+            pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+        };
+        id: string;
+        elementRef: import("@angular/core").ElementRef<HTMLElement>;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropsDirective, "[etProps]", never, { "props": { "alias": "etProps"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/props/template-input.d.ts

@@ -0,0 +1,30 @@
+import { ComponentType } from '@angular/cdk/portal';
+import { Injector, Signal, TemplateRef } from '@angular/core';
+export type AnyTemplateType = string | TemplateRef<unknown> | ComponentType<unknown> | TemplateRefWithContext | ComponentTypeWithInputs;
+export type TemplateRefWithContext<T = Record<string, unknown> | undefined, J = unknown> = {
+    template: TemplateRef<J>;
+    context?: T;
+    injector?: Injector;
+};
+export type ComponentTypeWithInputs<T = Record<string, unknown> | undefined, J = unknown> = {
+    component: ComponentType<J>;
+    inputs?: T;
+    injector?: Injector;
+};
+export type StringTemplate = {
+    type: 'string';
+    value: string;
+};
+export type NgTemplateTemplate = {
+    type: 'template';
+    value: TemplateRef<unknown>;
+    context?: Record<string, unknown>;
+    injector: Injector | null;
+};
+export type ComponentTemplate = {
+    type: 'component';
+    value: ComponentType<unknown>;
+    inputs?: Record<string, unknown>;
+    injector: Injector | null;
+};
+export declare const templateComputed: (templateSignal: Signal<AnyTemplateType | null>) => Signal<StringTemplate | NgTemplateTemplate | ComponentTemplate | null>;

package/lib/public-api.d.ts

@@ -3,6 +3,7 @@ export * from './constants/public-api';
 export * from './decorators/public-api';
 export * from './directives/public-api';
 export * from './pipes/public-api';
+export * from './props';
 export * from './services/public-api';
 export * from './types/public-api';
 export * from './utils/public-api';

package/lib/services/viewport.service.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { Breakpoint } from '../types';
 import * as i0 from "@angular/core";
-interface Size {
+export interface Size {
     width: number;
     height: number;
 }
@@ -62,4 +62,3 @@ export declare class ViewportService {
     static ɵfac: i0.ɵɵFactoryDeclaration<ViewportService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ViewportService>;
 }
-export {};

package/lib/utils/component-id.utils.d.ts

@@ -0,0 +1 @@
+export declare const createComponentId: (prefix: string) => string;

package/lib/utils/cookie.util.d.ts

@@ -1,5 +1,5 @@
 export declare const hasCookie: (name: string) => boolean;
 export declare const getCookie: (name: string) => string | null | undefined;
-export declare const setCookie: (name: string, data: string, expiresInDays?: number, domain?: string | null, path?: string) => void;
+export declare const setCookie: (name: string, data: string, expiresInDays?: number, domain?: string | null, path?: string, sameSite?: 'strict' | 'none' | 'lax') => void;
 export declare const deleteCookie: (name: string, path?: string, domain?: string | null) => void;
 export declare const getDomain: () => string | null;

package/lib/utils/public-api.d.ts

@@ -3,6 +3,7 @@ export * from './angular.utils';
 export * from './animation.utils';
 export * from './clamp.util';
 export * from './clone.util';
+export * from './component-id.utils';
 export * from './cookie.util';
 export * from './destroy.utils';
 export * from './equal.util';

package/lib/utils/selection-model.utils.d.ts

@@ -1,3 +1,4 @@
+import { TrackByFunction } from '@angular/core';
 import { Observable } from 'rxjs';
 import { TypedQueryList } from '../types';
 export type SelectionModelTypes = string | number | Record<string, unknown> | unknown;
@@ -61,6 +62,7 @@ export declare class SelectionModel<T extends SelectionModelTypes = unknown> {
     setAllowMultiple(allowMultiple: boolean): this;
     setFilter(filter: string | null): void;
     reset(): void;
+    trackByOptionKey: TrackByFunction<T>;
     getOptionByValue$(value: unknown): Observable<T | undefined>;
     getOptionByLabel$(label: string): Observable<T | undefined>;
     getOptionByKey$(key: string): Observable<T | undefined>;

package/lib/utils/signal.utils.d.ts

@@ -20,32 +20,53 @@ export declare const buildSignalEffects: <T extends Record<string, Signal<unknow
     }) => void;
 }) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalIsRendered: () => Signal<boolean>;
 export declare const signalClasses: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, classMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalHostClasses: <T extends Record<string, Signal<unknown>>>(classMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalAttributes: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, attributeMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalHostAttributes: <T extends Record<string, Signal<unknown>>>(attributeMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalStyles: <T extends Record<string, Signal<unknown>>>(el: SignalElementBindingType, styleMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export declare const signalHostStyles: <T extends Record<string, Signal<unknown>>>(styleMap: T) => {
     remove: (...tokens: string[]) => void;
+    removeMany: (tokens: string[]) => void;
     has: (token: string) => boolean;
+    push: (tokenString: string, signal: Signal<unknown>) => void;
+    pushMany: (map: Record<string, Signal<unknown>>) => void;
 };
 export interface LogicalSize {
     inlineSize: number;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/core",
-  "version": "4.4.1",
+  "version": "4.5.1",
   "peerDependencies": {
-    "@angular/cdk": "17.0.4",
-    "@angular/common": "17.0.8",
-    "@angular/core": "17.0.8",
-    "@angular/forms": "17.0.8",
-    "@angular/platform-browser": "17.0.8",
-    "@angular/router": "17.0.8",
+    "@angular/cdk": "17.1.1",
+    "@angular/common": "17.1.1",
+    "@angular/core": "17.1.1",
+    "@angular/forms": "17.1.1",
+    "@angular/platform-browser": "17.1.1",
+    "@angular/router": "17.1.1",
     "@ethlete/theming": "^2.3.1",
     "@ethlete/types": "^1.6.2",
     "@floating-ui/dom": "^1.5.3",