@evance/evance-ui 1.0.0

package/dist/util/dimensions.d.ts

@@ -0,0 +1,92 @@
+export declare const axes: readonly ["x", "y"];
+export type Axis = typeof axes[number];
+/**
+ * # Coordinates
+ * Two-dimensional coordinates (x,y).
+ */
+export interface Coordinates {
+    x: number;
+    y: number;
+}
+/**
+ * # Dimensions
+ */
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+/**
+ * # Position
+ * Representative of an element's position attributes describing the bounding area of a box.
+ */
+export interface Position {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * # Margins
+ * Essentially the same as Position, but is intended to describe areas outside the box
+ * (same as CSS `margin`).
+ */
+export type Margins = Position;
+export interface RectProps extends Coordinates, Dimensions {
+}
+/**
+ * # Rect
+ *
+ * Describes a bounding rectangle a bit like DOMRect, but not readonly.
+ */
+export declare class Rect implements Coordinates, Dimensions, Position {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+    /**
+     * ## Add Offset
+     * @param offset
+     */
+    addOffset(offset: Coordinates): Rect;
+    /**
+     * ## From Element
+     * @param el
+     * @param beforeTransforms
+     */
+    static fromElement(el: HTMLElement, beforeTransforms?: boolean): Rect;
+    /**
+     * ## From Rect
+     * Kind of replicates DOMRect.fromRect()
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMRect/fromRect_static
+     * @param rect
+     */
+    static fromRect(rect: DOMRect | Rect | RectProps): Rect;
+    /**
+     * ## Get Overflow
+     * Returns the overflow margins based on a second Rect.
+     * @param b
+     */
+    getOverflow(b: Rect): Margins;
+}
+/**
+ * # Adjust Bounding Rect
+ *
+ * Calculate Bounding Rect before being transformed.
+ *
+ * This doesn't account for skew or rotate translations, but at least it produces correct edge positions
+ * when scale is used and does not impose much of a performance penalty when there is no transform.
+ *
+ * @see https://stackoverflow.com/a/57876601/2074736
+ */
+export declare function adjustedBoundingRect(el: HTMLElement): Rect;
+/**
+ * # getTargetRect
+ *
+ * @param target
+ */
+export declare function getTargetRect(target: HTMLElement | [x: number, y: number]): Rect | DOMRect;

package/dist/util/events.d.ts

@@ -0,0 +1,68 @@
+import { PropType } from 'vue';
+
+/**
+ * # Click Event Listeners
+ * Standard listeners for click events.
+ */
+export interface ClickEventListeners {
+    onClick?: EventProp | undefined;
+    onClickOnce?: EventProp | undefined;
+}
+export type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+export declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
+/**
+ * # Call Event
+ * @param eventHandler
+ * @param args
+ */
+export declare function callEvent<T extends any[]>(eventHandler: EventProp<T> | undefined, ...args: T): void;
+/**
+ * # Event Name
+ * @param propName
+ */
+export declare function eventName(propName: string): string;
+/**
+ * # Focusable Elements
+ * A list of elements we can focus on dynamically.
+ */
+export declare const focusableElements: string[];
+/**
+ * # Focus Position
+ */
+export type FocusPosition = 'next' | 'previous' | 'first' | 'last';
+/**
+ * # Focus Child
+ * @param el
+ * @param position
+ */
+export declare function focusChild(el?: Element, position?: FocusPosition): HTMLElement | undefined;
+/**
+ * # Get Focusable Children
+ *
+ * Find and return any focusable elements within the supplied element,
+ * unless they're disabled or have a negative `tabindex` of -1.
+ *
+ * @param el
+ * @param filterByTabIndex
+ */
+export declare function getFocusableChildren(el: Element, filterByTabIndex?: boolean): HTMLElement[];
+/**
+ * # Has Event Listener
+ *
+ * Determines whether the `props` supplied includes an event listener, or
+ * any variations of the event listener. For example, 'click' events may have:
+ * - 'onClick'
+ * - 'onClickOnce'
+ * - 'onClickOnceCapture'
+ * - 'onClickCaptureOnce'
+ *
+ * @param props
+ * @param name
+ */
+export declare function hasEventListener(props: Record<string, any>, name: string): boolean;
+/**
+ * ## Add Scroll Event Listeners to Element (and its parents)
+ * @param el
+ * @param onScroll
+ */
+export declare function addScrollEventListener(el: HTMLElement | undefined, onScroll: (e: Event) => void): void;

package/dist/util/helpers.d.ts

@@ -0,0 +1,161 @@
+import { ComponentOptions, ComponentPublicInstance, ComputedGetter, ToRefs } from 'vue';
+
+export declare function getNextId(): number;
+export declare namespace getNextId {
+    var reset: () => void;
+}
+/**
+ * # Getter Property Key
+ *
+ * Defines where to look for Property information within getter functions.
+ *
+ * For example: an object might have a `title` property.
+ * So a property key may represent either an array index, or an object property.
+ *
+ * - `boolean` - Ignored
+ * - `string` - Property name, or use Object path notation.
+ * - `array` of strings or numbers represent nested lookup - each array element represents a key in the hierarchy
+ */
+export type GetterPropertyKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+/**
+ * # Get Property
+ *
+ * A getter function, which gets a property from the `subject`, which may be
+ * any kind of object.
+ *
+ */
+export declare function getPropertyValue(subject: any, property: GetterPropertyKey, fallback?: any): any;
+/**
+ * # Get Property from Path
+ *
+ * This is a rough copy of Evance's `EvObjectPathGetter` functionality.
+ *
+ * @param subject
+ * @param objectPath
+ * @param fallback
+ */
+export declare function getPropertyValueByPath(subject: any, objectPath: string, fallback?: any): any;
+/**
+ * # Get Nested Property Value
+ *
+ * @param subject
+ * @param propertyKeys
+ * @param fallback
+ */
+export declare function getNestedPropertyValue(subject: any, propertyKeys: PropertyKey[], fallback?: any): any;
+/**
+ * # Object Path To Array
+ *
+ * This is a rough copy of Evance's `EvObjectPath` functionality.
+ *
+ * @param path
+ */
+export declare function objectPathToPropertyKeys(path: string): PropertyKey[];
+/**
+ * # Ref Element
+ * @param obj
+ */
+export declare function refElement<T extends object | undefined>(obj: T): Exclude<T, ComponentPublicInstance> | HTMLElement;
+/**
+ * # Split Object
+ *
+ * Split an object into two using an Array of keys or RegExp to test keys against.
+ *
+ * This results an array containing an object containing only matching keys,
+ * and an object containing the remaining keys.
+ *
+ * @param subject
+ * @param paths
+ * @param exclude
+ */
+export declare function splitObject<Subject extends object, SubjectKey extends Extract<keyof Subject, string>, Exclusions extends Extract<keyof Subject, string>>(subject: Subject, paths: (SubjectKey | RegExp)[], exclude?: Exclusions[]): [matched: Partial<Subject>, unmatched: Partial<Subject>];
+/**
+ * ## Split Input Attrs
+ *
+ * Filter/split an attributes objects into two objects:
+ * 1. Attributes not intended for an input field.
+ * 2. Attributes for an input field.
+ *
+ * @param attrs
+ */
+export declare function splitInputAttrs(attrs: Record<string, unknown>): [matched: Partial<Record<string, unknown>>, unmatched: Partial<Record<string, unknown>>];
+/**
+ * # Clamp
+ *
+ * @param value
+ * @param min
+ * @param max
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+type NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;
+type _NotAUnion<T, U> = U extends any ? [T] extends [U] ? unknown : never : never;
+/**
+ * # Destruct Computed
+ *
+ * Convert a computed ref to a record of refs.
+ * The getter function must always return an object with the same keys.
+ */
+export declare function destructComputed<T extends object>(getter: ComputedGetter<T & NotAUnion<T>>): ToRefs<T>;
+/**
+ * # Union To Intersection
+ *
+ * Intersection `I` of all types in the union `U` - transform a union of object types into an intersection of those types.
+ * This can be helpful when you want to combine multiple types into a single type, where all properties from each type
+ * become part of the resulting type.
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * # Get Descriptor
+ *
+ * Returns the closest property descriptor for an object.
+ *
+ * @param obj
+ * @param key
+ */
+export declare function getPropertyDescriptor(obj: any, key: PropertyKey): TypedPropertyDescriptor<any> | undefined;
+/**
+ * # Filter Component Props
+ *
+ * Extracts the component's props from a props record.
+ *
+ * Excludes `class` and `style`.
+ *
+ * @param component
+ * @param props
+ */
+export declare function filterComponentProps(component: ComponentOptions<any>, props: Record<string, any>): Partial<Record<string, any>>;
+/**
+ * # If Any
+ */
+type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
+/**
+ * # Wrap In Array
+ * @param value
+ */
+export declare function wrapInArray<T>(value: T | null | undefined): T extends readonly any[] ? IfAny<T, T[], T> : NonNullable<T>[];
+export declare function mergeDeep(source?: Record<string, any>, target?: Record<string, any>, arrayFn?: (a: unknown[], b: unknown[]) => unknown[]): Record<string, any>;
+/**
+ * # Create Range
+ *
+ * @param length
+ * @param start
+ */
+export declare function createRange(length: number, start?: number): number[];
+/**
+ * # Omit
+ *
+ * Clones an object, whilst omitting excluded properties.
+ *
+ * @param obj
+ * @param exclude
+ */
+export declare function omit<T extends object, U extends Extract<keyof T, string>>(obj: T, exclude: U[]): Omit<T, U>;
+/**
+ * # matchesSelector
+ * Returns `null` if the CSS selector is not supported, or can't be checked.
+ * @param el
+ * @param selector
+ */
+export declare function matchesSelector(el: Element | undefined, selector: string): boolean | null;
+export declare function keys<O extends {}>(o: O): (keyof O)[];
+export {};

package/dist/util/index.d.ts

@@ -0,0 +1,23 @@
+export * from './anchor';
+export * from './animate';
+export * from './appearance';
+export * from './array';
+export * from './bindProps';
+export * from './browser';
+export * from './children';
+export * from './components';
+export * from './console';
+export * from './dimensions';
+export * from './events';
+export * from './helpers';
+export * from './injectSelf';
+export * from './is-functions';
+export * from './isFixedPosition';
+export * from './keyboard';
+export * from './modifiers';
+export * from './numbers';
+export * from './props';
+export * from './scroll';
+export * from './strings';
+export * from './style';
+export * from './units';

package/dist/util/injectSelf.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/dist/util/is-functions.d.ts

@@ -0,0 +1,100 @@
+/**
+ * # Is (equal)
+ * I had written a polyfill for this, but since we're only interested in modern browsers
+ * let's reduce code and simply return the result from Object.is();
+ * @param a
+ * @param b
+ */
+export declare function is(a?: any, b?: any): boolean;
+/**
+ * # Is Array?
+ * @param value
+ */
+export declare function isArray(value: unknown): boolean;
+/**
+ * # Is Boolean?
+ * @param value
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * # Is CSS Variable
+ * @param value
+ */
+export declare function isCssVariable(value: unknown): boolean;
+/**
+ * # Is Date?
+ * @param value
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * # Is Date Equal
+ *
+ * Evaluates whether one date equals another date.
+ *
+ * @param a
+ * @param b
+ */
+export declare function isDateEqual(a: Date, b: Date): boolean;
+/**
+ * # Is Deep Equal?
+ *
+ * I could have used the `deep-equal` npm package, but decided to keep things as light-weight
+ * as possible and this suits our needs for now:
+ *
+ * @link https://www.npmjs.com/package/deep-equal
+ *
+ * @param a
+ * @param b
+ */
+export declare function isDeepEqual(a: any, b: any): boolean;
+export declare function isElement(el: unknown): el is Element;
+/**
+ * # Is Empty
+ * @param value
+ */
+export declare function isEmpty(value: any): boolean;
+/**
+ * # Is Equal NaN
+ *
+ * Check if a value is NaN - the only value in JavaScript that is not equal to itself.
+ *
+ * @param value
+ */
+export declare function isEqualNaN(value: unknown): boolean;
+/**
+ * # Is Function?
+ * @param value
+ */
+export declare function isFunction(value: unknown): value is Function;
+/**
+ * # Is Number
+ * @param value
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * # Is Object?
+ * @param value
+ */
+export declare function isObject(value: unknown): value is object;
+/**
+ * # Is Object Not Array
+ * @param value
+ */
+export declare function isObjectNotArray(value: any): boolean;
+export declare const isOn: (key: string) => boolean;
+/**
+ *
+ * @param value
+ */
+export declare function isPrimitive(value: unknown): value is string | number | boolean;
+/**
+ * # Is ShadowRoot
+ * @param value
+ */
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+/**
+ * # Is String?
+ * @param value
+ */
+export declare function isString(value: unknown): value is string;
+export declare function isTypeOf(value: unknown, accept: string[]): boolean;

package/dist/util/isFixedPosition.d.ts

@@ -0,0 +1 @@
+export declare function isFixedPosition(el?: HTMLElement): boolean;

package/dist/util/keyboard.d.ts

@@ -0,0 +1,24 @@
+/**
+ * # Key Logger
+ */
+export declare class KeyLogger {
+    lastTime: number;
+    timeToKeep: number;
+    value: string;
+    /**
+     * ## Log
+     * @param e
+     */
+    log(e: KeyboardEvent): boolean;
+}
+/**
+ * # Is Key Event Loggable?
+ * @param e
+ */
+export declare function isKeyEventLoggable(e: KeyboardEvent): boolean;
+/**
+ * # isComposingIgnoreKey
+ * Returns `true` if the keyboard event is within a composing sequence,
+ * and the key pressed is included within `compositionIgnoreKeys`.
+ */
+export declare function isComposingIgnoreKey(e: KeyboardEvent): boolean;

package/dist/util/modifiers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ## Make Class Name
+ * Accepts a string `value` and a `prefix` to be combined and separated by a dash ("-").
+ * The value will be converted into "kebab-case".
+ * @param value
+ * @param prefix
+ * @param exclude
+ */
+export declare function makeClassName(value?: string, prefix?: string, exclude?: (string | RegExp)[]): string | undefined;
+/**
+ * ## Make a Size Modifier Class Name
+ * @param value
+ * @param exclude
+ */
+export declare function sizeModifier(value?: string | number, exclude?: (string | RegExp)[]): string | undefined;
+/**
+ * ## Make an Appearance Modifier Class Name
+ * @param value
+ * @param exclude
+ */
+export declare function appearanceModifier(value: string, exclude?: (string | RegExp)[]): string | undefined;
+/**
+ * ## Make a Variant Modifier Class Name
+ * @param value
+ * @param exclude
+ */
+export declare function variantModifier(value: string, exclude?: (string | RegExp)[]): string | undefined;

package/dist/util/numbers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * # Integerish Pattern
+ */
+export declare const IntegerishPattern: RegExp;
+/**
+ * # Is Integerish
+ * @param value
+ */
+export declare function isIntegerish(value: string | number): boolean;

package/dist/util/props.d.ts

@@ -0,0 +1,62 @@
+import { ComponentObjectPropsOptions, Prop, PropType } from 'vue';
+import { IfAny } from '@vue/shared';
+
+/**
+ * # Props Factory
+ *
+ * Creates a factory function for props definitions.
+ * This is used to define props in a composable then override
+ * default values in an implementing component.
+ *
+ * @example Simplified signature
+ * (props: Props) => (defaults?: Record<keyof props, any>) => Props
+ *
+ * @example Usage
+ * const makeProps = propsFactory({
+ *   foo: String,
+ * })
+ *
+ * defineComponent({
+ *   props: {
+ *     ...makeProps({
+ *       foo: 'a',
+ *     }),
+ *   },
+ *   setup (props) {
+ *     // would be "string | undefined", now "string" because a default has been provided
+ *     props.foo
+ *   },
+ * }
+ *
+ * Copied from Vuetify
+ * @see https://github.com/vuetifyjs/vuetify/blob/master/packages/vuetify/src/util/propsFactory.ts
+ */
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => AppendDefault<PropsOptions, Defaults>;
+type AppendDefault<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);
+/**
+ * Like `Partial<T>` but doesn't care what the value is
+ */
+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/dist/util/scroll.d.ts

@@ -0,0 +1,51 @@
+import { Axis } from './dimensions.ts';
+
+/**
+ * # Get Scroll Parent
+ *
+ * Get the closest parent element which is scrollable.
+ *
+ * @param el
+ * @param isIncludeHidden
+ * @param axis
+ */
+export declare function getScrollParent(el?: Element, isIncludeHidden?: boolean, axis?: Axis | null): HTMLElement;
+/**
+ * # Get Scroll Parents
+ *
+ * Get all parent elements with a scrollbar in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param stopAt
+ * @param axis
+ */
+export declare function getScrollParents(el: Element | undefined, stopAt?: Element | null, axis?: Axis | null): HTMLElement[];
+/**
+ * # Has Scrollbar?
+ *
+ * Determine whether an Element has a Scrollbar in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * This does not necessarily mean it has a scroll amount.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param axis
+ */
+export declare function hasScrollbar(el?: Element | null, axis?: Axis | null): boolean;
+/**
+ * # Is Scrollable?
+ *
+ * Determines whether an Element is scrollable in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param axis
+ */
+export declare function isScrollable(el: Element | null, axis?: Axis | null): boolean;