yuyeon 0.3.3 → 0.3.4-beta.13

package/types/src/util/color/palettes/tonal-palette.d.ts

@@ -0,0 +1,40 @@
+import { Hct } from '../hct/hct';
+
+/**
+ *  A convenience class for retrieving colors that are constant in hue and
+ *  chroma, but vary in tone.
+ */
+export declare class TonalPalette {
+    readonly hue: number;
+    readonly chroma: number;
+    readonly keyColor: Hct;
+    private readonly cache;
+    /**
+     * @param argb ARGB representation of a color
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromInt(argb: number): TonalPalette;
+    /**
+     * @param hct Hct
+     * @return Tones matching that color's hue and chroma.
+     */
+    static fromHct(hct: Hct): TonalPalette;
+    /**
+     * @param hue HCT hue
+     * @param chroma HCT chroma
+     * @return Tones matching hue and chroma.
+     */
+    static fromHueAndChroma(hue: number, chroma: number): TonalPalette;
+    private constructor();
+    private static createKeyColor;
+    /**
+     * @param tone HCT tone, measured from 0 to 100.
+     * @return ARGB representation of a color with that tone.
+     */
+    tone(tone: number): number;
+    /**
+     * @param tone HCT tone.
+     * @return HCT representation of a color with that tone.
+     */
+    getHct(tone: number): Hct;
+}

package/types/src/util/color/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * RGBA component
+ *
+ * @param r Red value should be between 0-255
+ * @param g Green value should be between 0-255
+ * @param b Blue value should be between 0-255
+ * @param a Alpha value should be between 0-255
+ */
+export interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}

package/types/src/util/color/utils/math-utils.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Utility methods for mathematical operations.
+ */
+/**
+ * The signum function.
+ *
+ * @return 1 if num > 0, -1 if num < 0, and 0 if num = 0
+ */
+export declare function signum(num: number): number;
+/**
+ * The linear interpolation function.
+ *
+ * @return start if amount = 0 and stop if amount = 1
+ */
+export declare function lerp(start: number, stop: number, amount: number): number;
+/**
+ * Clamps an integer between two integers.
+ *
+ * @return input when min <= input <= max, and either min or max
+ * otherwise.
+ */
+export declare function clampInt(min: number, max: number, input: number): number;
+/**
+ * Clamps an integer between two floating-point numbers.
+ *
+ * @return input when min <= input <= max, and either min or max
+ * otherwise.
+ */
+export declare function clampDouble(min: number, max: number, input: number): number;
+/**
+ * Sanitizes a degree measure as an integer.
+ *
+ * @return a degree measure between 0 (inclusive) and 360
+ * (exclusive).
+ */
+export declare function sanitizeDegreesInt(degrees: number): number;
+/**
+ * Sanitizes a degree measure as a floating-point number.
+ *
+ * @return a degree measure between 0.0 (inclusive) and 360.0
+ * (exclusive).
+ */
+export declare function sanitizeDegreesDouble(degrees: number): number;
+/**
+ * Sign of direction change needed to travel from one angle to
+ * another.
+ *
+ * For angles that are 180 degrees apart from each other, both
+ * directions have the same travel distance, so either direction is
+ * shortest. The value 1.0 is returned in this case.
+ *
+ * @param from The angle travel starts from, in degrees.
+ * @param to The angle travel ends at, in degrees.
+ * @return -1 if decreasing from leads to the shortest travel
+ * distance, 1 if increasing from leads to the shortest travel
+ * distance.
+ */
+export declare function rotationDirection(from: number, to: number): number;
+/**
+ * Distance of two points on a circle, represented using degrees.
+ */
+export declare function differenceDegrees(a: number, b: number): number;
+/**
+ * Multiplies a 1x3 row vector with a 3x3 matrix.
+ */
+export declare function matrixMultiply(row: number[], matrix: number[][]): number[];

package/types/src/util/common.d.ts

@@ -0,0 +1,17 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: <explanation> */
+export declare function hasOwnProperty(object: any, property: string): boolean;
+export declare function getNestedValue(obj: any, path: (string | number)[], fallback?: any): any;
+export declare function mergeDeep(source?: Record<string, any>, overwrite?: Record<string, any>, arrayFn?: (source: unknown[], overwrite: unknown[]) => unknown[]): {
+    [x: string]: any;
+};
+export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
+export type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+export declare function getPropertyFromItem(item: any, property: SelectItemKey, fallback?: any): any;
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare function getRangeArr(length: number, start?: number): number[];
+export declare function deepEqual(a: any, b: any): boolean;
+export declare function isObject(obj: unknown): boolean;
+export declare function isEmpty(target: any): boolean;
+export declare function omit<T extends object, U extends Extract<keyof T, string>>(obj: T, excludes: U[]): Omit<T, U>;
+export declare const noop: () => undefined;
+export declare function makeEventPromiseLike<T extends Event, P = any>(event: T, promise: Promise<P>): T & Promise<P>;

package/types/src/util/component/component.d.ts

@@ -0,0 +1,5 @@
+import { Component, ComponentInjectOptions, ComponentOptionsMixin, ComponentProvideOptions, ComputedOptions, DefineComponent, Directive, EmitsOptions, MethodOptions, SlotsType, ComponentObjectPropsOptions, ComponentOptionsWithObjectProps, ComponentOptionsWithoutProps, ExtractDefaultPropTypes } from 'vue';
+
+declare function redefineComponent<PropsOptions = {}, RawBindings = {}, E extends EmitsOptions = {}, EE extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions>(options: ComponentOptionsWithoutProps<PropsOptions, RawBindings, Data, Computed, Methods, Mixin, Extends, E, EE, InjectOptions, InjectKeys, Slots>): DefineComponent<PropsOptions, RawBindings, Data, Computed, Methods, Mixin, Extends, E, EE>;
+declare function redefineComponent<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, E extends EmitsOptions = {}, EE extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, Defaults = ExtractDefaultPropTypes<PropsOptions>, InjectOptions extends {} = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions>(options: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, Data, Computed, Methods, Mixin, Extends, E, EE, InjectOptions, InjectKeys, Slots>): DefineComponent<PropsOptions, RawBindings, Data, Computed, Methods, Mixin, Extends, E, EE>;
+export { redefineComponent as defineComponent };

package/types/src/util/component/index.d.ts

@@ -0,0 +1,11 @@
+import { ComponentInternalInstance, ComponentPublicInstance, InjectionKey, VNode, VNodeChild } from 'vue';
+import { defineComponent } from './component';
+
+export type { EventProp } from './types';
+export * from './props';
+export { defineComponent };
+export declare function getSlot(vm: ComponentPublicInstance | any, name?: string, data?: any | (() => any), optional?: boolean): VNode[] | undefined;
+export declare function getUid(): number | undefined;
+export declare function bindClasses(classes: string | string[] | Record<string, any> | undefined): Record<string, boolean>;
+export declare function getHtmlElement<N extends object | undefined>(node: N): Exclude<N, ComponentPublicInstance> | HTMLElement;
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];

package/types/src/util/component/inject-self.d.ts

@@ -0,0 +1,3 @@
+import { ComponentInternalInstance, InjectionKey } from 'vue';
+
+export declare function injectSelf<T>(key: InjectionKey<T> | string, vm?: ComponentInternalInstance): T | undefined;

package/types/src/util/component/props.d.ts

@@ -0,0 +1,32 @@
+import { ComponentObjectPropsOptions, ExtractPropTypes, Prop, PropType, VNode } from 'vue';
+import { IfAny } from '@vue/shared';
+
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => OverwrittenPropOptions<PropsOptions, Defaults>;
+export declare function chooseProps<PropsOptions extends ComponentObjectPropsOptions>(props: any, target: PropsOptions): ExtractPropTypes<PropsOptions>;
+export declare function hasEventProp(props: Record<string, any>, type: string): boolean;
+export declare function propIsDefined(vnode: VNode, prop: string): boolean;
+type OverwrittenPropOptions<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+export {};

package/types/src/util/component/types.d.ts

@@ -0,0 +1,21 @@
+import { EmitsOptions, ObjectEmitsOptions, PropType } from 'vue';
+
+export type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+export declare const EventPropOption: <T extends any[] = any[]>() => PropType<EventProp<T>>;
+export type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any[]>;
+export type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? {
+    [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
+} : T extends ObjectEmitsOptions ? {
+    [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : never) => any;
+} : {};
+export type TypeEmitsToOptions<T extends ComponentTypeEmits> = {
+    [K in keyof T & string]: T[K] extends [...args: infer Args] ? (...args: Args) => any : () => any;
+} & (T extends (...args: any[]) => any ? ParametersToFns<OverloadParameters<T>> : {});
+type ParametersToFns<T extends any[]> = {
+    [K in T[0]]: K extends `${infer C}` ? (...args: T extends [C, ...infer Args] ? Args : never) => any : never;
+};
+export type OverloadParameters<T extends (...args: any[]) => any> = Parameters<OverloadUnion<T>>;
+type OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
+type OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...args: infer TArgs) => infer TReturn ? TPartialOverload extends TOverload ? never : OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: TArgs) => TReturn) & OverloadProps<TOverload>> | ((...args: TArgs) => TReturn) : never;
+type OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
+export {};

package/types/src/util/date/adapters/yuyeon-date-adapter.d.ts

@@ -0,0 +1,43 @@
+import { DateAdapter, DateFormatOptions } from '../types';
+
+export declare class YuyeonDateAdapter implements DateAdapter<Date> {
+    locale: string;
+    formats?: Record<string, DateFormatOptions>;
+    constructor(options: {
+        locale: string;
+        formats?: Record<string, DateFormatOptions>;
+    });
+    getWeekArray(date: Date): Date[][];
+    startOfMonth(date: Date): Date;
+    endOfMonth(date: Date): Date;
+    addDays(date: Date, amount: number): Date;
+    addMonths(date: Date, amount: number): Date;
+    date(value?: any): Date | null;
+    endOfDay(date: Date): Date;
+    endOfYear(date: Date): Date;
+    format(date: Date, formatString: string): string;
+    getDiff(date: Date, comparing: string | Date, unit?: string): number;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDay(date: Date): number;
+    getNextMonth(date: Date): Date;
+    getWeekdays(): string[];
+    isAfter(date: Date, comparing: Date): boolean;
+    isBefore(date: Date, comparing: Date): boolean;
+    isEqual(date: Date, comparing: Date): boolean;
+    isSameDay(date: Date, comparing: Date): boolean;
+    isSameMonth(date: Date, comparing: Date): boolean;
+    isValid(date: any): boolean;
+    isWithinRange(date: Date, range: [Date, Date]): boolean;
+    parseISO(date: string): Date;
+    setMonth(date: Date, month: number): Date;
+    setYear(date: Date, year: number): Date;
+    startOfDay(date: Date): Date;
+    startOfYear(date: Date): Date;
+    toISO(date: Date): string;
+    toJsDate(date: Date): Date;
+    getHour(date: Date): number;
+    getMinute(date: Date): number;
+    setHour(date: Date, hour: number): Date;
+    setMinute(date: Date, minute: number): Date;
+}

package/types/src/util/date/built-in.d.ts

@@ -0,0 +1,41 @@
+import { DateAdapter, DateFormatOptions } from './types';
+
+export declare const ONE_DAY: number;
+export declare const YYYY_MM_DD_REGEX: RegExp;
+export declare const FIRST_SUNDAY: Date;
+export declare class DateUtil {
+    static date(value?: any): Date | null;
+    static format(value: Date, formatString: string, locale: string, formats?: Record<string, DateFormatOptions>): string;
+    static parseLocalDate(value: string): Date;
+    static parseISO(value: string): Date;
+    static toISO(adapter: DateAdapter<any>, value: Date): string;
+    static getWeekArray(date: Date, locale: string): Date[][];
+    static startOfMonth(date: Date): Date;
+    static endOfMonth(date: Date): Date;
+    static startOfDay(date: Date): Date;
+    static startOfYear(date: Date): Date;
+    static endOfDay(date: Date): Date;
+    static endOfYear(date: Date): Date;
+    static getYear(date: Date): number;
+    static getMonth(date: Date): number;
+    static getDay(date: Date): number;
+    static getNextMonth(date: Date): Date;
+    static getWeekdays(locale: string): string[];
+    static getMeridians(locale: string): string[];
+    static isAfter(date: Date, comparing: Date): boolean;
+    static isBefore(date: Date, comparing: Date): boolean;
+    static isEqual(date: Date, comparing: Date): boolean;
+    static isSameDay(date: Date, comparing: Date): boolean;
+    static isSameMonth(date: Date, comparing: Date): boolean;
+    static isValid(date: any): boolean;
+    static isWithinRange(date: Date, range: [Date, Date]): boolean;
+    static addDays(date: Date, amount: number): Date;
+    static addMonths(date: Date, amount: number): Date;
+    static getDiff(date: Date, comparing: string | Date, unit?: 'month' | string): number;
+    static setMonth(date: Date, month: number): Date;
+    static setYear(date: Date, year: number): Date;
+    static getHour(date: Date): number;
+    static setHour(date: Date, hour: number): Date;
+    static getMinute(date: Date): number;
+    static setMinute(date: Date, minute: number): Date;
+}

package/types/src/util/date/index.d.ts

@@ -0,0 +1,3 @@
+export { YuyeonDateAdapter } from './adapters/yuyeon-date-adapter';
+export * from './built-in';
+export declare function createDateAdapter(): void;

package/types/src/util/date/types.d.ts

@@ -0,0 +1,167 @@
+export interface DateAdapter<T = unknown> {
+    /**
+     *
+     * @param value
+     */
+    date(value?: any): T | null;
+    /**
+     *
+     * @param date
+     * @param formatString
+     */
+    format(date: T, formatString: string): string;
+    /**
+     *
+     * @param value
+     */
+    toJsDate(value: T): Date;
+    /**
+     *
+     * @param date
+     */
+    parseISO(date: string): T;
+    /**
+     *
+     * @param date
+     */
+    toISO(date: T): string;
+    /**
+     *
+     * @param date
+     */
+    startOfDay(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfDay(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    startOfMonth(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfMonth(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    startOfYear(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfYear(date: T): T;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isBefore(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isAfter(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isEqual(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isSameDay(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isSameMonth(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     */
+    isValid(date: any): boolean;
+    /**
+     *
+     * @param date
+     * @param range
+     */
+    isWithinRange(date: T, range: [T, T]): boolean;
+    /**
+     *
+     * @param date
+     * @param amount
+     */
+    addDays(date: T, amount: number): T;
+    /**
+     *
+     * @param date
+     * @param amount
+     */
+    addMonths(date: T, amount: number): T;
+    /**
+     *
+     * @param date
+     */
+    getYear(date: T): number;
+    /**
+     *
+     * @param date
+     * @param year
+     */
+    setYear(date: T, year: number): T;
+    /**
+     *
+     * @param date
+     * @param comparing
+     * @param unit
+     */
+    getDiff(date: T, comparing: T | string, unit?: string): number;
+    /**
+     *
+     *
+     * @param date
+     */
+    getWeekArray(date: T): T[][];
+    /**
+     *
+     */
+    getWeekdays(): string[];
+    /**
+     *  0 ~ 11
+     * @param date
+     */
+    getMonth(date: T): number;
+    /**
+     *
+     * @param date
+     * @param month
+     */
+    setMonth(date: T, month: number): T;
+    /**
+     *
+     * get day (1-31) number
+     *
+     * @param date
+     */
+    getDay(date: T): number;
+    /**
+     *
+     * @param date
+     */
+    getNextMonth(date: T): T;
+    getHour(date: T): number;
+    setHour(date: T, hour: number): T;
+    getMinute(date: T): number;
+    setMinute(date: T, minute: number): T;
+}
+export type DateFormatOptions = Intl.DateTimeFormatOptions | ((date: Date, formatString: string, locale: string) => string);

package/types/src/util/debounce.d.ts

@@ -0,0 +1,11 @@
+interface DebouncedFn<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+}
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
+    leading: boolean;
+    maxWait?: number;
+    trailing: boolean;
+}): DebouncedFn<T>;
+export {};

package/types/src/util/dom.d.ts

@@ -0,0 +1,5 @@
+export declare function documentRoot(domNode: Node): null | HTMLDocument | ShadowRoot;
+export declare function hasElementMouseEvent(mouseEvent: Event, element: HTMLElement, include?: HTMLElement[]): boolean;
+export declare function isOverflow(el: HTMLElement): boolean;
+export declare const focusableSelectors = "input:not([disabled]), textarea:not([disabled]), select:not([disabled]), button:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+export declare function getNextTabElement(currentElement: Element): undefined | Element;

package/types/src/util/environments.d.ts

@@ -0,0 +1,6 @@
+declare const Environments: {
+    isBrowser: boolean;
+    canUseIntersectionObserver: boolean;
+    canUseResizeObserver: boolean;
+};
+export default Environments;

package/types/src/util/frame-scheduler.d.ts

@@ -0,0 +1,7 @@
+export declare class FrameScheduler {
+    private clean;
+    private frames;
+    private raf;
+    private run;
+    requestNewFrame(callback: () => void): void;
+}

package/types/src/util/index.d.ts

@@ -0,0 +1,16 @@
+export * from './anchor';
+export * from './array';
+export * from './collection';
+export * from './color';
+export * from './common';
+export * from './component';
+export * from './date';
+export * from './debounce';
+export * from './dom';
+export * from './frame-scheduler';
+export * from './reactivity';
+export * from './rect';
+export * from './scroll';
+export * from './string';
+export * from './ui';
+export * from './validation';

package/types/src/util/reactivity.d.ts

@@ -0,0 +1,7 @@
+import { ComputedGetter } from 'vue';
+
+/**
+ * For Destructuring assignment
+ * @param getter
+ */
+export declare function $computed<T extends object>(getter: ComputedGetter<T>): import('vue').ToRefs<T>;

package/types/src/util/rect.d.ts

@@ -0,0 +1,36 @@
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare class MutableRect implements Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor({ x, y, width, height, }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare function getOverflow(a: MutableRect, b: MutableRect): {
+    x: {
+        before: number;
+        after: number;
+    };
+    y: {
+        before: number;
+        after: number;
+    };
+};

package/types/src/util/scroll.d.ts

@@ -0,0 +1,3 @@
+export declare function getScrollParent(el?: HTMLElement, horizontal?: boolean): HTMLElement;
+export declare function getScrollParents(el?: Element | null, stopAt?: Element | null, horizontal?: boolean): HTMLElement[];
+export declare function hasScrollbar(el?: Element | null, horizontal?: boolean): boolean;

package/types/src/util/string.d.ts

@@ -0,0 +1,9 @@
+export declare function camelToPascal(str: string): string;
+export declare function toKebabCase(str: string, from?: 'camel' | 'pascal'): string;
+export declare function kebabToCamel(str: string): string;
+export declare function randomCharOne(str: string): string;
+export declare function simpleBraceParse(input: string): {
+    type: string;
+    content: string;
+}[];
+export declare function escapeRegExp(str: string): string;

package/types/src/util/ui.d.ts

@@ -0,0 +1,4 @@
+export declare function getBoundingPureRect(el: HTMLElement): DOMRect;
+export declare function pixelRound(val: number): number;
+export declare function pixelCeil(val: number): number;
+export declare function toStyleSizeValue(size: number | string | null | undefined, unit?: string): string | undefined;

package/types/src/util/validation.d.ts

@@ -0,0 +1,3 @@
+export declare function REQUIRE_RULE(value: any): boolean;
+declare const _default: {};
+export default _default;

package/types/types/index.d.ts

@@ -4,3 +4,6 @@ export type CandidateKey = string | number;
 export type JSXComponent<Props = any> = FunctionalComponent<Props> | {
     new (): ComponentPublicInstance<Props>;
 };
+export type CssProperties = {
+    [p: `--${string}`]: string | number | undefined;
+};

package/types/util/anchor.d.ts

@@ -15,7 +15,7 @@ export type ParsedAnchor = {
 };
 /** Parse a raw anchor string into an object */
 export declare function parseAnchor(anchor: Anchor, isRtl: boolean): ParsedAnchor;
-export declare function toPhysical(str: 'center' | Tblock | Tinline, isRtl: boolean): "top" | "bottom" | "left" | "right" | "center";
+export declare function toPhysical(str: 'center' | Tblock | Tinline, isRtl: boolean): "bottom" | "left" | "right" | "top" | "center";
 export declare function flipSide(anchor: ParsedAnchor): ParsedAnchor;
 export declare function flipAlign(anchor: ParsedAnchor): ParsedAnchor;
 export declare function flipCorner(anchor: ParsedAnchor): ParsedAnchor;

package/types/util/common.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: <explanation> */
 export declare function hasOwnProperty(object: any, property: string): boolean;
 export declare function getNestedValue(obj: any, path: (string | number)[], fallback?: any): any;
 export declare function mergeDeep(source?: Record<string, any>, overwrite?: Record<string, any>, arrayFn?: (source: unknown[], overwrite: unknown[]) => unknown[]): {
@@ -12,3 +13,5 @@ export declare function deepEqual(a: any, b: any): boolean;
 export declare function isObject(obj: unknown): boolean;
 export declare function isEmpty(target: any): boolean;
 export declare function omit<T extends object, U extends Extract<keyof T, string>>(obj: T, excludes: U[]): Omit<T, U>;
+export declare const noop: () => undefined;
+export declare function makeEventPromiseLike<T extends Event, P = any>(event: T, promise: Promise<P>): T & Promise<P>;