@lmvz-ds/components 0.11.4

package/dist/types/utils/component.d.ts

@@ -0,0 +1,36 @@
+import type { EventEmitter } from '../stencil-public-runtime';
+export declare const transitionEndAsync: (el: HTMLElement | null, expectedDuration?: number) => Promise<unknown>;
+export declare const componentOnReady: (el: any, callback: any) => void;
+export declare const hasLazyBuild: (stencilEl: HTMLElement) => boolean;
+export type Attributes = {
+    [key: string]: any;
+};
+export declare const inheritAttributes: (el: HTMLElement, attributes?: string[]) => Attributes;
+export declare const inheritAriaAttributes: (el: HTMLElement, ignoreList?: string[]) => Attributes;
+export declare const addEventListener: (el: any, eventName: string, callback: any, opts?: any) => any;
+export declare const removeEventListener: (el: any, eventName: string, callback: any, opts?: any) => any;
+export declare const getElementRoot: (el: HTMLElement, fallback?: HTMLElement) => HTMLElement | ShadowRoot;
+export declare const raf: (h: FrameRequestCallback) => number;
+export declare const hasShadowDom: (el: HTMLElement) => boolean;
+export declare const focusVisibleElement: (el: HTMLElement) => void;
+export declare const renderHiddenInput: (always: boolean, container: HTMLElement, name: string, value: string | undefined | null, disabled: boolean) => void;
+export declare const clamp: (min: number, n: number, max: number) => number;
+export declare const assert: (actual: any, reason: string) => void;
+export declare const now: (ev: UIEvent) => number;
+export declare const pointerCoord: (ev: any) => {
+    x: number;
+    y: number;
+};
+export declare const deferEvent: (event: EventEmitter) => EventEmitter;
+export declare const debounceEvent: (event: EventEmitter, wait: number) => EventEmitter;
+export declare const debounce: (func: (...args: any[]) => void, wait?: number) => (...args: any[]) => any;
+export declare const shallowEqualStringMap: (map1: {
+    [k: string]: any;
+} | undefined, map2: {
+    [k: string]: any;
+} | undefined) => boolean;
+export declare const isSafeNumber: (input: unknown) => input is number;
+export declare function getDeepActiveElement(root?: Document): Element;
+export declare function canReceiveFocus(el: Element): boolean;
+export type FormRef = string | HTMLFormElement | undefined;
+export declare function findFormByRef(form: FormRef, el: HTMLElement): HTMLFormElement | null;

package/dist/types/utils/effect.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from 'effect';
+export type UnwrapEffect<T> = T extends Effect.Effect<infer A, infer E, infer R> ? [A, E, R] : never;
+export declare function run<T extends Effect.Effect<unknown, unknown, never>>(effect: T): T extends Effect.Effect<infer A, infer E, never> ? Promise<A | E> : never;

package/dist/types/utils/element-activation-controller.d.ts

@@ -0,0 +1,19 @@
+import type { EventEmitter } from '../stencil-public-runtime';
+import type { ReactiveController } from './reactive-controller-host';
+export type ElementActivationHost = {
+    el: HTMLElement;
+    lmvzActivation: EventEmitter<void>;
+};
+type Config = {
+    localHandler?: (event: Event) => unknown;
+    keys?: string[];
+};
+export declare class ElementActivationController implements ReactiveController {
+    private host;
+    private config?;
+    constructor(host: ElementActivationHost, config?: Config);
+    hostDidLoad(): void;
+    private handleKeyDown;
+    private handleActivation;
+}
+export {};

package/dist/types/utils/http.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+declare const FetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FetchError";
+} & Readonly<A>;
+export declare class FetchError extends FetchError_base<{
+    cause: unknown;
+}> {
+}
+declare const NotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NotFoundError";
+} & Readonly<A>;
+export declare class NotFoundError extends NotFoundError_base<{
+    url: string;
+}> {
+}
+export declare const httpClient: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, FetchError | NotFoundError, never>;
+declare const ResponseTextError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ResponseTextError";
+} & Readonly<A>;
+export declare class ResponseTextError extends ResponseTextError_base<Error> {
+    constructor(error: Error);
+}
+export declare const responseAsText: (res: Response) => Effect.Effect<string, ResponseTextError, never>;
+export {};

package/dist/types/utils/http.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/list-keyboard-controller.d.ts

@@ -0,0 +1,13 @@
+import type { ReactiveController } from './reactive-controller-host';
+export type ListKeyboardNavigationHost = {
+    el: HTMLElement;
+};
+export declare class ListKeyboardNavigationController implements ReactiveController {
+    private readonly host;
+    private elements;
+    constructor(host: ListKeyboardNavigationHost);
+    hostDidRender(): void;
+    updateElements(elements: Element[]): void;
+    private handleKeydown;
+    private getNextFocusableElement;
+}

package/dist/types/utils/public.d.ts

@@ -0,0 +1 @@
+export { run } from './effect';

package/dist/types/utils/reactive-controller-host.d.ts

@@ -0,0 +1,26 @@
+import { ComponentInterface } from '../stencil-public-runtime';
+export interface ReactiveController {
+    hostConnected?(): void;
+    hostDisconnected?(): void;
+    hostWillLoad?(): Promise<void> | void;
+    hostDidLoad?(): void;
+    hostWillRender?(): Promise<void> | void;
+    hostDidRender?(): void;
+    hostWillUpdate?(): Promise<void> | void;
+    hostDidUpdate?(): void;
+    readonly disabled?: boolean;
+}
+export declare class ReactiveControllerHost implements ComponentInterface {
+    private controllers;
+    protected addController(controller: ReactiveController): void;
+    protected removeController(controller: ReactiveController): void;
+    private get activeControllers();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    componentWillRender(): void;
+    componentDidRender(): void;
+    componentWillUpdate(): void;
+    componentDidUpdate(): void;
+}

package/dist/types/utils/typing.d.ts

@@ -0,0 +1,3 @@
+export type AtLeastOneKey<T> = {
+    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
+}[keyof T];

package/dist/types/utils/url.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from 'effect';
+declare const URLCreationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "URLCreationError";
+} & Readonly<A>;
+export declare class URLCreationError extends URLCreationError_base<Error> {
+}
+export declare const createAssetUrlWithBasePath: (file: string, basePath?: string) => Effect.Effect<string, never, never>;
+export {};

package/dist/types/utils/validation/aria-validation-controller.d.ts

@@ -0,0 +1,31 @@
+import type { ReactiveController } from '../reactive-controller-host';
+export type AriaValidationHost<T extends HTMLElement = HTMLElement> = {
+    el: T;
+};
+type Config = {
+    reValidateOnPropChanges?: boolean;
+    verboseLogging?: boolean;
+};
+export declare class AriaValidationController implements ReactiveController {
+    private readonly host;
+    private readonly config?;
+    private static get globalValidationEnabled();
+    private static axe;
+    private static axeQueue;
+    private static axeStreamFiber;
+    private visibilityObserver?;
+    private elementQueued;
+    private elementValidated;
+    private knownValidationErrors;
+    get disabled(): boolean;
+    constructor(host: AriaValidationHost, config?: Config);
+    private static initializeAxeStream;
+    hostDidLoad(): void;
+    hostDidUpdate(): void;
+    hostDisconnected(): void;
+    private observeVisibilityOnce;
+    private checkLazyValidation;
+    private enqueueValidation;
+    private discardVisibilityObserver;
+}
+export {};

package/dist/types/utils/validation/svg.d.ts

@@ -0,0 +1,11 @@
+import { Brand, Effect } from 'effect';
+export type SVGString = string & Brand.Brand<'SVG'>;
+export declare const SVGString: Brand.Brand.Constructor<SVGString>;
+declare const BrandValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BrandValidationError";
+} & Readonly<A>;
+export declare class BrandValidationError extends BrandValidationError_base<Error> {
+    constructor(error: Error, type: string);
+}
+export declare const createValidSVGString: (svg: string) => Effect.Effect<SVGString, BrandValidationError, never>;
+export {};

package/hydrate/index.d.ts

@@ -0,0 +1,287 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { Readable } from 'node:stream';
+
+export declare function createWindowFromHtml(templateHtml: string, uniqueId: string): any;
+export type TagTransformer = (tag: string) => string;
+/**
+ * Serialize a value to a string that can be deserialized later.
+ * @param {unknown} value - The value to serialize.
+ * @returns {string} A string that can be deserialized later.
+ * @deprecated will be removed in v5. Use `@PropSerialize()` decorator instead.
+ */
+export declare function serializeProperty(value: unknown): string | number | boolean;
+/**
+ * Deserialize a value from a string that was serialized earlier.
+ * @param {string} value - The string to deserialize.
+ * @returns {unknown} The deserialized value.
+ * @deprecated will be removed in v5. Use `@AttrDeserialize()` decorator instead.
+ */
+export declare function deserializeProperty(value: string): any;
+export type ResolutionHandler = (elm: HTMLElement) => string | undefined | null;
+export interface HydrateDocumentOptions {
+	/**
+	 * Build ID that will be added to `<html data-stencil-build="BUILD_ID">`. By default
+	 * a random ID will be generated
+	 */
+	buildId?: string;
+	/**
+	 * Sets the `href` attribute on the `<link rel="canonical">`
+	 * tag within the `<head>`. If the value is not defined it will
+	 * ensure a canonical link tag is no included in the `<head>`.
+	 */
+	canonicalUrl?: string;
+	/**
+	 * Include the HTML comments and attributes used by the client-side
+	 * JavaScript to read the structure of the HTML and rebuild each
+	 * component. Defaults to `true`.
+	 */
+	clientHydrateAnnotations?: boolean;
+	/**
+	 * Constrain `setTimeout()` to 1ms, but still async. Also
+	 * only allows `setInterval()` to fire once, also constrained to 1ms.
+	 * Defaults to `true`.
+	 */
+	constrainTimeouts?: boolean;
+	/**
+	 * Sets `document.cookie`
+	 */
+	cookie?: string;
+	/**
+	 * Sets the `dir` attribute on the top level `<html>`.
+	 */
+	direction?: string;
+	/**
+	 * Component tag names listed here will not be prerendered, nor will
+	 * hydrated on the client-side. Components listed here will be ignored
+	 * as custom elements and treated no differently than a `<div>`.
+	 */
+	excludeComponents?: string[];
+	/**
+	 * Sets the `lang` attribute on the top level `<html>`.
+	 */
+	language?: string;
+	/**
+	 * Maximum number of components to hydrate on one page. Defaults to `300`.
+	 */
+	maxHydrateCount?: number;
+	/**
+	 * Sets `document.referrer`
+	 */
+	referrer?: string;
+	/**
+	 * Removes every `<script>` element found in the `document`. Defaults to `false`.
+	 */
+	removeScripts?: boolean;
+	/**
+	 * Removes CSS not used by elements within the `document`. Defaults to `true`.
+	 */
+	removeUnusedStyles?: boolean;
+	/**
+	 * The url the runtime uses for the resources, such as the assets directory.
+	 */
+	resourcesUrl?: string;
+	/**
+	 * Prints out runtime console logs to the NodeJS process. Defaults to `false`.
+	 */
+	runtimeLogging?: boolean;
+	/**
+	 * Component tags listed here will only be prerendered or server-side-rendered
+	 * and will not be client-side hydrated. This is useful for components that
+	 * are not dynamic and do not need to be defined as a custom element within the
+	 * browser. For example, a header or footer component would be a good example that
+	 * may not require any client-side JavaScript.
+	 */
+	staticComponents?: string[];
+	/**
+	 * The amount of milliseconds to wait for a page to finish rendering until
+	 * a timeout error is thrown. Defaults to `15000`.
+	 */
+	timeout?: number;
+	/**
+	 * Sets `document.title`.
+	 */
+	title?: string;
+	/**
+	 * Sets `location.href`
+	 */
+	url?: string;
+	/**
+	 * Sets `navigator.userAgent`
+	 */
+	userAgent?: string;
+	/**
+	 * Configure how Stencil serializes the components shadow root.
+	 * - If set to `declarative-shadow-dom` the component will be rendered within a Declarative Shadow DOM.
+	 * - If set to `scoped` Stencil will render the contents of the shadow root as a `scoped: true` component
+	 *   and the shadow DOM will be created during client-side hydration.
+	 * - Alternatively you can mix and match the two by providing an object with `declarative-shadow-dom` and `scoped` keys,
+	 * the value arrays containing the tag names of the components that should be rendered in that mode.
+	 *
+	 * Examples:
+	 * - `{ 'declarative-shadow-dom': ['my-component-1', 'another-component'], default: 'scoped' }`
+	 * Render all components as `scoped` apart from `my-component-1` and `another-component`
+	 * -  `{ 'scoped': ['an-option-component'], default: 'declarative-shadow-dom' }`
+	 * Render all components within `declarative-shadow-dom` apart from `an-option-component`
+	 * - `'scoped'` Render all components as `scoped`
+	 * - `false` disables shadow root serialization
+	 *
+	 * *NOTE* `true` has been deprecated in favor of `declarative-shadow-dom` and `scoped`
+	 * @default 'declarative-shadow-dom'
+	 */
+	serializeShadowRoot?: "declarative-shadow-dom" | "scoped" | {
+		"declarative-shadow-dom"?: string[];
+		scoped?: string[];
+		default: "declarative-shadow-dom" | "scoped";
+	} | boolean;
+}
+export interface SerializeDocumentOptions extends HydrateDocumentOptions {
+	/**
+	 * Runs after the `document` has been hydrated.
+	 */
+	afterHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Sets an approximate line width the HTML should attempt to stay within.
+	 * Note that this is "approximate", in that HTML may often not be able
+	 * to be split at an exact line width. Additionally, new lines created
+	 * is where HTML naturally already has whitespace, such as before an
+	 * attribute or spaces between words. Defaults to `100`.
+	 */
+	approximateLineWidth?: number;
+	/**
+	 * Runs before the `document` has been hydrated.
+	 */
+	beforeHydrate?(document: any): any | Promise<any>;
+	/**
+	 * Format the HTML in a nicely indented format.
+	 * Defaults to `false`.
+	 */
+	prettyHtml?: boolean;
+	/**
+	 * Remove quotes from attribute values when possible.
+	 * Defaults to `true`.
+	 */
+	removeAttributeQuotes?: boolean;
+	/**
+	 * Remove the `=""` from standardized `boolean` attributes,
+	 * such as `hidden` or `checked`. Defaults to `true`.
+	 */
+	removeBooleanAttributeQuotes?: boolean;
+	/**
+	 * Remove these standardized attributes when their value is empty:
+	 * `class`, `dir`, `id`, `lang`, and `name`, `title`. Defaults to `true`.
+	 */
+	removeEmptyAttributes?: boolean;
+	/**
+	 * Remove HTML comments. Defaults to `true`.
+	 */
+	removeHtmlComments?: boolean;
+	/**
+	 * The `fullDocument` flag determines the format of the rendered output. Set it to true to
+	 * generate a complete HTML document, or false to render only the component.
+	 * @default true
+	 */
+	fullDocument?: boolean;
+	/**
+	 * Style modes to render the component in.
+	 * @see https://stenciljs.com/docs/styling#style-modes
+	 */
+	modes?: ResolutionHandler[];
+}
+export interface HydrateFactoryOptions extends SerializeDocumentOptions {
+	serializeToHtml: boolean;
+	destroyWindow: boolean;
+	destroyDocument: boolean;
+}
+export interface Diagnostic {
+	absFilePath?: string | undefined;
+	code?: string;
+	columnNumber?: number | undefined;
+	debugText?: string;
+	header?: string;
+	language?: string;
+	level: "error" | "warn" | "info" | "log" | "debug";
+	lineNumber?: number | undefined;
+	lines: PrintLine[];
+	messageText: string;
+	relFilePath?: string | undefined;
+	type: string;
+}
+export interface PrintLine {
+	lineIndex: number;
+	lineNumber: number;
+	text: string;
+	errorCharStart: number;
+	errorLength?: number;
+}
+export interface HydrateResults {
+	buildId: string;
+	diagnostics: Diagnostic[];
+	url: string;
+	host: string | null;
+	hostname: string | null;
+	href: string | null;
+	port: string | null;
+	pathname: string | null;
+	search: string | null;
+	hash: string | null;
+	html: string | null;
+	components: HydrateComponent[];
+	anchors: HydrateAnchorElement[];
+	imgs: HydrateImgElement[];
+	scripts: HydrateScriptElement[];
+	styles: HydrateStyleElement[];
+	staticData: HydrateStaticData[];
+	title: string | null;
+	hydratedCount: number;
+	httpStatus: number | null;
+}
+export interface HydrateComponent {
+	tag: string;
+	mode: string;
+	count: number;
+	depth: number;
+}
+export interface HydrateElement {
+	[attrName: string]: string | undefined;
+}
+export interface HydrateAnchorElement extends HydrateElement {
+	href?: string;
+	target?: string;
+}
+export interface HydrateImgElement extends HydrateElement {
+	src?: string;
+}
+export interface HydrateScriptElement extends HydrateElement {
+	src?: string;
+	type?: string;
+}
+export interface HydrateStyleElement extends HydrateElement {
+	id?: string;
+	href?: string;
+	content?: string;
+}
+export interface HydrateStaticData {
+	id: string;
+	type: string;
+	content: string;
+}
+export declare function streamToString(html: string | any, option?: SerializeDocumentOptions): Readable;
+export declare function renderToString(html: string | any, options?: SerializeDocumentOptions): Promise<HydrateResults>;
+export declare function renderToString(html: string | any, options: SerializeDocumentOptions | undefined, asStream: true): Readable;
+export declare function hydrateDocument(doc: any | string, options?: HydrateDocumentOptions): Promise<HydrateResults>;
+export declare function hydrateDocument(doc: any | string, options: HydrateDocumentOptions | undefined, asStream?: boolean): Readable;
+export declare function serializeDocumentToString(doc: Document, opts: HydrateFactoryOptions): string;
+/**
+ * Transforms a tag name using the current tag transformer
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+export declare function transformTag<T extends string>(tag: T): T;
+/**
+ * Sets the tag transformer to be used when rendering custom elements
+ * @param transformer the transformer function to use. Must return a string
+ */
+export declare function setTagTransformer(transformer: TagTransformer): void;
+
+export {};