@public-ui/components 4.0.3-rc.2 → 4.0.4-rc.0

package/dist/types/internal/functional-components/click-button/controller.d.ts

@@ -0,0 +1,12 @@
+import { BaseController } from '../base-controller';
+import type { ControllerInterface, ResolvedInputProps } from '../generic-types';
+import type { ClickButtonApi } from './api';
+export declare class ClickButtonController extends BaseController<ClickButtonApi> implements ControllerInterface<ClickButtonApi> {
+    private buttonRef?;
+    constructor(states?: ClickButtonApi['States']);
+    componentWillLoad(props: ResolvedInputProps<ClickButtonApi>): void;
+    watchLabel(value?: string): void;
+    handleClick: () => void;
+    focus(): void;
+    setButtonRef: (element?: HTMLButtonElement) => void;
+}

package/dist/types/internal/functional-components/generic-types.d.ts

@@ -0,0 +1,86 @@
+import type { EventEmitter } from '../../stencil-public-runtime';
+import type { JSXBase } from '../../stencil-public-runtime';
+type Callback<T> = (value?: T) => void;
+export type StrictFields<T> = {
+    [K in keyof T]-?: NonNullable<T[K]>;
+};
+export type InternalOf<P> = {
+    [K in keyof P as K extends `__input_${string}` | '__propInternal__' ? never : K]: P[K];
+};
+type ExternalOf<P> = {
+    [K in keyof P as K extends `__input_${string}` | '__propInternal__' ? never : K]: `__input_${K & string}` extends keyof P ? NonNullable<P[`__input_${K & string}`]> : P[K];
+};
+type PropsDefinition = {
+    Optional?: Record<string, unknown>;
+    Required?: Record<string, unknown>;
+};
+export interface ComponentApi {
+    Callbacks?: Record<string, () => unknown>;
+    Emitters?: Record<string, unknown>;
+    Listeners?: Record<string, unknown>;
+    Methods?: Record<string, (...args: never[]) => unknown>;
+    Props?: PropsDefinition;
+    Refs?: Record<string, HTMLElement>;
+    States?: Record<string, unknown>;
+}
+type PropsEntry<T extends ComponentApi, K extends keyof PropsDefinition> = T['Props'] extends PropsDefinition ? T['Props'][K] extends Record<string, unknown> ? T['Props'][K] : Record<never, never> : Record<never, never>;
+type RequiredProps<T extends ComponentApi> = PropsEntry<T, 'Required'>;
+type OptionalProps<T extends ComponentApi> = PropsEntry<T, 'Optional'>;
+type AllProps<T extends ComponentApi> = RequiredProps<T> & OptionalProps<T>;
+export type ResolvedProps<T extends ComponentApi> = InternalOf<RequiredProps<T>> & Partial<InternalOf<OptionalProps<T>>>;
+export type ResolvedInputProps<T extends ComponentApi> = ExternalOf<RequiredProps<T>> & Partial<ExternalOf<OptionalProps<T>>>;
+type ApiField<T extends ComponentApi, K extends keyof ComponentApi> = T[K] extends Record<string, unknown> ? T[K] : Record<never, never>;
+type ExtractCallbacks<T extends ComponentApi> = ApiField<T, 'Callbacks'>;
+type ExtractEmitters<T extends ComponentApi> = ApiField<T, 'Emitters'>;
+type ExtractListeners<T extends ComponentApi> = ApiField<T, 'Listeners'>;
+type ExtractMethods<T extends ComponentApi> = ApiField<T, 'Methods'>;
+type ExtractRefs<T extends ComponentApi> = ApiField<T, 'Refs'>;
+type ExtractStates<T extends ComponentApi> = InternalOf<ApiField<T, 'States'>>;
+type InternalProps<T extends ComponentApi> = InternalOf<AllProps<T>>;
+type ExternalProps<T extends ComponentApi> = ExternalOf<AllProps<T>>;
+type PromiseMethod<Methods> = {
+    [K in keyof Methods]: Methods[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : Methods[K];
+};
+type ComponentPropsRequired<Props> = {
+    [K in keyof Props as `_${Lowercase<string & K>}`]: Props[K];
+};
+type ComponentPropsOptional<Props> = {
+    [K in keyof Props as `_${Lowercase<string & K>}`]?: Props[K];
+};
+type ComponentProps<T extends ComponentApi> = ComponentPropsRequired<ExternalOf<RequiredProps<T>>> & ComponentPropsOptional<ExternalOf<OptionalProps<T>>>;
+type ComponentWatchers<Props> = {
+    [K in keyof Props as `watch${Capitalize<string & K>}`]: Callback<Props[K]>;
+};
+type ComponentEmitters<Emitters> = {
+    [K in keyof Emitters as `${Lowercase<string & K>}`]: EventEmitter<Emitters[K]>;
+};
+type ComponentListeners<Listeners> = {
+    [K in keyof Listeners as `on${Capitalize<string & K>}`]: (event: Listeners[K]) => void;
+};
+export type WebComponentInterface<T extends ComponentApi> = {
+    componentWillLoad(): void;
+} & ComponentProps<T> & StrictFields<ExtractStates<T>> & ComponentWatchers<ExternalProps<T>> & ComponentEmitters<ExtractEmitters<T>> & PromiseMethod<ExtractMethods<T>> & ComponentListeners<ExtractListeners<T>>;
+type ComponentCallbacks<Callbacks> = {
+    [K in keyof Callbacks as `handle${Capitalize<string & K>}`]: Callbacks[K];
+};
+type ComponentRefs<Refs> = {
+    [K in keyof Refs as `ref${Capitalize<string & K>}`]: (element?: Refs[K]) => void;
+};
+type FunctionalComponentEmitters<Emitters> = {
+    [K in keyof Emitters as `on${Capitalize<string & K>}`]: EventEmitter<Emitters[K]>;
+};
+export type FunctionalComponentProps<T extends ComponentApi> = StrictFields<InternalProps<T>> & StrictFields<ExtractStates<T>> & ComponentCallbacks<ExtractCallbacks<T>> & ComponentRefs<ExtractRefs<T>> & FunctionalComponentEmitters<ExtractEmitters<T>> & Partial<Omit<JSXBase.HTMLAttributes<HTMLElement>, keyof InternalProps<T> | keyof ExtractStates<T>>>;
+type ControllerCallbackHandlers<Callbacks> = {
+    [K in keyof Callbacks as `handle${Capitalize<string & K>}`]: (element?: Callbacks[K]) => void;
+};
+type ControllerListeners<Listeners> = {
+    [K in keyof Listeners as `on${Capitalize<string & K>}`]: (event: Listeners[K]) => void;
+};
+type ControllerRefSetters<Refs> = {
+    [K in keyof Refs as `set${Capitalize<string & K>}Ref`]: (element?: Refs[K]) => void;
+};
+export type ControllerInterface<T extends ComponentApi = ComponentApi> = {
+    componentWillLoad(props: ResolvedInputProps<T>): void;
+    getProps(): StrictFields<InternalProps<T>>;
+} & ComponentWatchers<ExternalProps<T>> & ControllerCallbackHandlers<ExtractCallbacks<T>> & ControllerListeners<ExtractListeners<T>> & ExtractMethods<T> & ControllerRefSetters<ExtractRefs<T>>;
+export {};

package/dist/types/internal/functional-components/skeleton/api.d.ts

@@ -0,0 +1,26 @@
+import type { CountProp, LabelProp, NameProp, ShowProp } from '../../props';
+import type { ComponentApi, InternalOf } from '../generic-types';
+export interface SkeletonApi extends ComponentApi {
+    Props: {
+        Optional: CountProp;
+        Required: NameProp;
+    };
+    States: InternalOf<CountProp> & LabelProp & ShowProp;
+    Emitters: {
+        loaded: number;
+        rendered: void;
+    };
+    Methods: {
+        focus: () => void;
+        toggle: () => void;
+    };
+    Listeners: {
+        keydown: KeyboardEvent;
+    };
+    Callbacks: {
+        click: () => void;
+    };
+    Refs: {
+        button: HTMLButtonElement;
+    };
+}

package/dist/types/internal/functional-components/skeleton/component.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionalComponent as FC } from '../../../stencil-public-runtime';
+import type { FunctionalComponentProps } from '../generic-types';
+import type { SkeletonApi } from './api';
+export declare const SkeletonFC: FC<FunctionalComponentProps<SkeletonApi>>;

package/dist/types/internal/functional-components/skeleton/controller.d.ts

@@ -0,0 +1,22 @@
+import { BaseController } from '../base-controller';
+import type { ControllerInterface, ResolvedInputProps } from '../generic-types';
+import type { SkeletonApi } from './api';
+export declare class SkeletonController extends BaseController<SkeletonApi> implements ControllerInterface<SkeletonApi> {
+    private readonly clickButtonCtrl;
+    private intervalId?;
+    constructor(states: SkeletonApi['States']);
+    componentWillLoad(props: ResolvedInputProps<SkeletonApi>): void;
+    watchCount(value?: number | string): void;
+    watchName(value?: string): void;
+    watchLabel(value?: string): void;
+    toggle(): void;
+    onKeydown: (event: KeyboardEvent) => void;
+    handleClick: () => void;
+    focus(): void;
+    setButtonRef: (element?: HTMLButtonElement) => void;
+    private startLoadedEventInterval;
+    private emitLoaded;
+    private onLoadedCallback?;
+    setOnLoadedCallback(callback: (count: number) => void): void;
+    destroy(): void;
+}

package/dist/types/internal/props/color.d.ts

@@ -0,0 +1,4 @@
+import type { ColorPair } from '../../schema';
+import { type Prop } from './helpers/factory';
+export type ColorProp = Prop<'color', ColorPair | string, ColorPair>;
+export declare const colorProp: import("./helpers/factory").PropDefinition<ColorPair>;

package/dist/types/internal/props/count.d.ts

@@ -0,0 +1,3 @@
+import { type Prop } from './helpers/factory';
+export type CountProp = Prop<'count', number | string, number>;
+export declare const countProp: import("./helpers/factory").PropDefinition<number>;

package/dist/types/internal/props/helpers/factory.d.ts

@@ -0,0 +1,15 @@
+export type Prop<K extends string, TExternal, TInternal> = {
+    [P in K]: TInternal;
+} & {
+    [P in K as `__input_${P}`]?: TExternal;
+} & {
+    readonly __propInternal__?: TInternal;
+};
+export type SimpleProp<K extends string, T> = Prop<K, T, T>;
+export type InternalPropValue<P extends Prop<string, unknown, unknown>> = NonNullable<P['__propInternal__']>;
+export type PropDefinition<TInternal> = {
+    normalize: (value: unknown) => TInternal | never;
+    validate: (value: TInternal) => boolean;
+};
+export declare function createPropDefinition<P extends Prop<string, unknown, unknown>>(normalize: (value: unknown) => InternalPropValue<P> | never, validate: (value: InternalPropValue<P>) => boolean): PropDefinition<InternalPropValue<P>>;
+export declare function withValidPropValue<P extends Prop<string, unknown, unknown>>(propDef: PropDefinition<InternalPropValue<P>>, value: unknown, callback: (normalized: InternalPropValue<P>) => void): void;

package/dist/types/internal/props/helpers/normalizers.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeString(value?: unknown): string | never;
+export declare function normalizeInteger(value?: unknown): number | never;
+export declare function normalizeNumber(value?: unknown): number | never;
+export declare function normalizeBoolean(value?: unknown): boolean | never;
+export declare function normalizeObject(value?: unknown): object | never;
+export declare function normalizeArray(value?: unknown): unknown[] | never;

package/dist/types/internal/props/index.d.ts

@@ -0,0 +1 @@
+export*from"./color";export*from"./count";export*from"./helpers/factory";export*from"./initials";export*from"./label";export*from"./name";export*from"./show";export*from"./src";

package/dist/types/internal/props/initials.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleProp } from './helpers/factory';
+export type InitialsProp = SimpleProp<'initials', string>;
+export declare const initialsProp: import("./helpers/factory").PropDefinition<string>;

package/dist/types/internal/props/label.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleProp } from './helpers/factory';
+export type LabelProp = SimpleProp<'label', string>;
+export declare const labelProp: import("./helpers/factory").PropDefinition<string>;

package/dist/types/internal/props/name.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleProp } from './helpers/factory';
+export type NameProp = SimpleProp<'name', string>;
+export declare const nameProp: import("./helpers/factory").PropDefinition<string>;

package/dist/types/internal/props/show.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleProp } from './helpers/factory';
+export type ShowProp = SimpleProp<'show', boolean>;
+export declare const showProp: import("./helpers/factory").PropDefinition<import("./helpers/factory").InternalPropValue<ShowProp>>;

package/dist/types/internal/props/src.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleProp } from './helpers/factory';
+export type SrcProp = SimpleProp<'src', string>;
+export declare const srcProp: import("./helpers/factory").PropDefinition<string>;

package/dist/types/schema/bem-registry.d.ts

@@ -0,0 +1,80 @@
+type KoliBriComponentsBemSchema = {
+    'kol-alert': {
+        elements: {
+            container: {
+                modifiers: null;
+            };
+            icon: {
+                modifiers: null;
+            };
+            heading: {
+                modifiers: Set<'h0' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'>;
+            };
+            content: {
+                modifiers: null;
+            };
+            closer: {
+                modifiers: null;
+            };
+        };
+        modifiers: Set<'hasCloser' | 'type-default' | 'type-error' | 'type-info' | 'type-success' | 'type-warning' | 'variant-card' | 'variant-msg'>;
+    };
+    'kol-avatar': {
+        elements: {
+            image: {
+                modifiers: null;
+            };
+            initials: {
+                modifiers: null;
+            };
+        };
+        modifiers: null;
+    };
+    'kol-icon': {
+        elements: {
+            icon: {
+                modifiers: null;
+            };
+        };
+        modifiers: null;
+    };
+    'kol-skeleton': {
+        elements: {
+            container: {
+                modifiers: null;
+            };
+            name: {
+                modifiers: null;
+            };
+            counter: {
+                modifiers: null;
+            };
+            actions: {
+                modifiers: null;
+            };
+        };
+        modifiers: Set<'has-name' | 'is-hidden'>;
+    };
+    'kol-click-button': {
+        elements: {
+            label: {
+                modifiers: null;
+            };
+        };
+        modifiers: null;
+    };
+};
+export declare const bem: {
+    <BlockName extends keyof KoliBriComponentsBemSchema, ElementName extends keyof NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>>(blockName: BlockName, blockModifiersOrElementName?: ElementName | ((KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T ? T extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T_1 ? T_1 extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T_1 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined, elementModifiers?: ((NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_2 ? T_2 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_2 extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_3 ? T_3 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_3 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined): string;
+    forBlock<BlockName extends keyof KoliBriComponentsBemSchema>(blockName: BlockName): {
+        <ElementName extends keyof NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>>(elementNameOrBlockModifiers?: ElementName | ((KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T ? T extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T_1 ? T_1 extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T_1 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined, elementModifiers?: ((NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_2 ? T_2 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_2 extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_3 ? T_3 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_3 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined): string;
+        forElement: <ElementName extends keyof NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>>(elementName: ElementName) => (elementModifiers?: ((NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T ? T extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_1 ? T_1 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_1 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined) => string;
+    };
+} & {
+    forBlock: <BlockName extends keyof KoliBriComponentsBemSchema>(blockName: BlockName) => {
+        <ElementName extends keyof NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>>(elementNameOrBlockModifiers?: ElementName | ((KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T ? T extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<KoliBriComponentsBemSchema[BlockName]["modifiers"] extends infer T_1 ? T_1 extends KoliBriComponentsBemSchema[BlockName]["modifiers"] ? T_1 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined, elementModifiers?: ((NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_2 ? T_2 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_2 extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_3 ? T_3 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_3 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined): string;
+        forElement: <ElementName extends keyof NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>>(elementName: ElementName) => (elementModifiers?: ((NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T ? T extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T extends Set<infer U> ? U : never : never : never) extends never ? undefined : Partial<Record<NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] extends infer T_1 ? T_1 extends NonNullable<KoliBriComponentsBemSchema[BlockName]["elements"]>[ElementName]["modifiers"] ? T_1 extends Set<infer U> ? U : never : never : never, boolean>>) | undefined) => string;
+    };
+};
+declare const BEM: KoliBriComponentsBemSchema;
+export { BEM };

package/dist/types/schema/props/color.d.ts

@@ -1,16 +1,10 @@
 import type { Generic } from 'adopted-style-sheets';
 import type { Stringified } from '../types';
 import type { WatchOptions } from '../utils';
-type CharacteristicColors = {
-    primary: string;
-    secondary: string;
-    neutral: string;
-};
 export type ColorPair = {
     backgroundColor: string;
-    foregroundColor: Stringified<CharacteristicColors>;
+    foregroundColor: string;
 };
 export type PropColor = ColorPair;
 export declare const validateColor: (component: Generic.Element.Component, value?: Stringified<PropColor>, options?: WatchOptions) => void;
 export declare const handleColorChange: (value: unknown) => ColorPair;
-export {};