		@@ -1,270 +0,5 @@
		import { ComponentPublicInstance, StyleValue, IntrinsicElementAttributes, ReservedProps, NativeElements, FunctionalComponent, DefineComponent, Events, VNode } from 'vue';
		export { OkuPrimitive, Primitive } from './primitive';
		export type { ComponentProps, RefElement, MergeProps, OkuElement, InstanceTypeRef, ComponentPublicInstanceRef, PrimitiveProps, StyleOmit, AriaAttributes, } from './types';
		export { primitiveProps, renderSlotFragments } from './utils';
		export { dispatchDiscreteCustomEvent } from './utils';
		export { omit as propsOmit, pick as propsPick } from 'filter-anything';

		declare const NODES: readonly ["a", "button", "div", "form", "h2", "h3", "img", "input", "label", "li", "nav", "ol", "p", "span", "svg", "ul"];
		interface NodeElementTagNameMap {
		a: HTMLAnchorElement;
		button: HTMLButtonElement;
		div: HTMLDivElement;
		form: HTMLFormElement;
		h2: HTMLHeadingElement;
		h3: HTMLHeadingElement;
		img: HTMLImageElement;
		input: HTMLInputElement;
		label: HTMLLabelElement;
		li: HTMLLIElement;
		nav: HTMLElement;
		ol: HTMLOListElement;
		p: HTMLParagraphElement;
		span: HTMLSpanElement;
		svg: SVGSVGElement;
		ul: HTMLUListElement;
		}
		interface IntrinsicElements extends NativeElements {
		[name: string]: any;
		}
		type ElementConstructor<P> = (new () => {
		$props: P;
		}) \| ((props: P, ...args: any) => FunctionalComponent<any, any>);
		type ComponentProps<T extends keyof IntrinsicElements \| ElementConstructor<any>> = T extends ElementConstructor<infer P> ? P : T extends keyof IntrinsicElements ? IntrinsicElements[T] : Record<string, never>;
		type RefElement<T extends abstract new (...args: any) => any> = Omit<InstanceType<T>, keyof ComponentPublicInstance \| 'class' \| 'style'>;
		type InstanceTypeRef<C extends abstract new (...args: any) => any, T> = Omit<InstanceType<C>, '$el'> & {
		$el: T;
		};
		type ComponentPublicInstanceRef<T> = Omit<ComponentPublicInstance, '$el'> & {
		$el: T;
		};
		type MergeProps<T, U> = U & T;
		interface PrimitiveProps {
		asChild?: boolean;
		}
		type Primitives = {
		[E in (typeof NODES)[number]]: DefineComponent<{
		asChild?: boolean;
		} & IntrinsicElementAttributes[E]> & NodeElementTagNameMap[E] & AriaAttributes;
		};
		type StyleOmit<T extends HTMLElement> = Partial<Omit<T, 'style'> & {
		style?: StyleValue;
		}> & AriaAttributes;
		type OmitElementEvents<T extends keyof NodeElementTagNameMap> = Omit<NodeElementTagNameMap[T], Lowercase<keyof Events> \| 'style'>;
		type OkuElement<T extends keyof NodeElementTagNameMap, TA extends boolean = true> = {
		[K in keyof OmitElementEvents<T>]?: OmitElementEvents<T>[K];
		} & Partial<IntrinsicElementAttributes[T]> & (TA extends true ? ReservedProps : object) & Partial<AriaAttributes>;
		type Booleanish = boolean \| 'true' \| 'false';
		type Numberish = number \| string;
		interface AriaAttributes {
		/** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */
		'aria-activedescendant'?: string;
		/** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */
		'aria-atomic'?: Booleanish;
		/**
		* Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be
		* presented if they are made.
		*/
		'aria-autocomplete'?: 'none' \| 'inline' \| 'list' \| 'both';
		/** Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user. */
		'aria-busy'?: Booleanish;
		/**
		* Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
		* @see aria-pressed @see aria-selected.
		*/
		'aria-checked'?: Booleanish \| 'mixed';
		/**
		* Defines the total number of columns in a table, grid, or treegrid.
		* @see aria-colindex.
		*/
		'aria-colcount'?: Numberish;
		/**
		* Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
		* @see aria-colcount @see aria-colspan.
		*/
		'aria-colindex'?: Numberish;
		/**
		* Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
		* @see aria-colindex @see aria-rowspan.
		*/
		'aria-colspan'?: Numberish;
		/**
		* Identifies the element (or elements) whose contents or presence are controlled by the current element.
		* @see aria-owns.
		*/
		'aria-controls'?: string;
		/** Indicates the element that represents the current item within a container or set of related elements. */
		'aria-current'?: Booleanish \| 'page' \| 'step' \| 'location' \| 'date' \| 'time';
		/**
		* Identifies the element (or elements) that describes the object.
		* @see aria-labelledby
		*/
		'aria-describedby'?: string;
		/**
		* Identifies the element that provides a detailed, extended description for the object.
		* @see aria-describedby.
		*/
		'aria-details'?: string;
		/**
		* Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
		* @see aria-hidden @see aria-readonly.
		*/
		'aria-disabled'?: Booleanish;
		/**
		* Indicates what functions can be performed when a dragged object is released on the drop target.
		* @deprecated in ARIA 1.1
		*/
		'aria-dropeffect'?: 'none' \| 'copy' \| 'execute' \| 'link' \| 'move' \| 'popup';
		/**
		* Identifies the element that provides an error message for the object.
		* @see aria-invalid @see aria-describedby.
		*/
		'aria-errormessage'?: string;
		/** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */
		'aria-expanded'?: Booleanish;
		/**
		* Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion,
		* allows assistive technology to override the general default of reading in document source order.
		*/
		'aria-flowto'?: string;
		/**
		* Indicates an element's "grabbed" state in a drag-and-drop operation.
		* @deprecated in ARIA 1.1
		*/
		'aria-grabbed'?: Booleanish;
		/** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */
		'aria-haspopup'?: Booleanish \| 'menu' \| 'listbox' \| 'tree' \| 'grid' \| 'dialog';
		/**
		* Indicates whether the element is exposed to an accessibility API.
		* @see aria-disabled.
		*/
		'aria-hidden'?: Booleanish;
		/**
		* Indicates the entered value does not conform to the format expected by the application.
		* @see aria-errormessage.
		*/
		'aria-invalid'?: Booleanish \| 'grammar' \| 'spelling';
		/** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
		'aria-keyshortcuts'?: string;
		/**
		* Defines a string value that labels the current element.
		* @see aria-labelledby.
		*/
		'aria-label'?: string;
		/**
		* Identifies the element (or elements) that labels the current element.
		* @see aria-describedby.
		*/
		'aria-labelledby'?: string;
		/** Defines the hierarchical level of an element within a structure. */
		'aria-level'?: Numberish;
		/** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */
		'aria-live'?: 'off' \| 'assertive' \| 'polite';
		/** Indicates whether an element is modal when displayed. */
		'aria-modal'?: Booleanish;
		/** Indicates whether a text box accepts multiple lines of input or only a single line. */
		'aria-multiline'?: Booleanish;
		/** Indicates that the user may select more than one item from the current selectable descendants. */
		'aria-multiselectable'?: Booleanish;
		/** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
		'aria-orientation'?: 'horizontal' \| 'vertical';
		/**
		* Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship
		* between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
		* @see aria-controls.
		*/
		'aria-owns'?: string;
		/**
		* Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value.
		* A hint could be a sample value or a brief description of the expected format.
		*/
		'aria-placeholder'?: string;
		/**
		* Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
		* @see aria-setsize.
		*/
		'aria-posinset'?: Numberish;
		/**
		* Indicates the current "pressed" state of toggle buttons.
		* @see aria-checked @see aria-selected.
		*/
		'aria-pressed'?: Booleanish \| 'mixed';
		/**
		* Indicates that the element is not editable, but is otherwise operable.
		* @see aria-disabled.
		*/
		'aria-readonly'?: Booleanish;
		/**
		* Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
		* @see aria-atomic.
		*/
		'aria-relevant'?: 'additions' \| 'additions text' \| 'all' \| 'removals' \| 'text';
		/** Indicates that user input is required on the element before a form may be submitted. */
		'aria-required'?: Booleanish;
		/** Defines a human-readable, author-localized description for the role of an element. */
		'aria-roledescription'?: string;
		/**
		* Defines the total number of rows in a table, grid, or treegrid.
		* @see aria-rowindex.
		*/
		'aria-rowcount'?: Numberish;
		/**
		* Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
		* @see aria-rowcount @see aria-rowspan.
		*/
		'aria-rowindex'?: Numberish;
		/**
		* Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
		* @see aria-rowindex @see aria-colspan.
		*/
		'aria-rowspan'?: Numberish;
		/**
		* Indicates the current "selected" state of various widgets.
		* @see aria-checked @see aria-pressed.
		*/
		'aria-selected'?: Booleanish;
		/**
		* Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
		* @see aria-posinset.
		*/
		'aria-setsize'?: Numberish;
		/** Indicates if items in a table or grid are sorted in ascending or descending order. */
		'aria-sort'?: 'none' \| 'ascending' \| 'descending' \| 'other';
		/** Defines the maximum allowed value for a range widget. */
		'aria-valuemax'?: Numberish;
		/** Defines the minimum allowed value for a range widget. */
		'aria-valuemin'?: Numberish;
		/**
		* Defines the current value for a range widget.
		* @see aria-valuetext.
		*/
		'aria-valuenow'?: Numberish;
		/** Defines the human readable text alternative of aria-valuenow for a range widget. */
		'aria-valuetext'?: string;
		}

		declare const Primitive: Primitives;
		declare const OkuPrimitive: Primitives;

		/**
		* When you create a component and pass a <slot />, Vue wraps
		* the contents of <slot /> inside a <Fragment /> component and assigns
		* the <slot /> VNode a type of Fragment.
		*
		* So why are we flattening here? Vue renders VNodes from the leaf
		* nodes going up to the root. In other words, when executing the render function
		* of each component, it executes the child render functions first before the parents.
		*
		* This means that at any components render function execution context, all it's children
		* VNodes should have already been rendered -- and that includes any slots! :D
		*
		* In the cases where we pass in a component with slots to the `asChild` component,
		* we shall need to flatten those slot fragment VNodes so as to extract all it's children VNodes
		* to correctly apply the props and event listeners from the with as child components.
		*
		* We do this recursively to ensure that all first child slots that contain fragments in their descendants are rendered into VNodes before passing events.
		* to the first actual element VNode.
		*/
		declare function renderSlotFragments(children: VNode[]): VNode[];
		declare function dispatchDiscreteCustomEvent<E extends CustomEvent>(target: E['target'], event: E): void;
		declare const primitiveProps: {
		asChild: BooleanConstructor;
		};

		export { type AriaAttributes, type ComponentProps, type ComponentPublicInstanceRef, type InstanceTypeRef, type MergeProps, type OkuElement, OkuPrimitive, Primitive, type PrimitiveProps, type RefElement, type StyleOmit, dispatchDiscreteCustomEvent, primitiveProps, renderSlotFragments };

package.json

		{
		"name": "@oku-ui/primitive",
		"type": "module",
		"version": "0.6.0",
		"version": "0.6.1",
		"license": "MIT",
		@@ -46,4 +46,6 @@ "source": "src/index.ts",
		"release": "pnpm build && pnpm bumpp --commit='version(primitive): release %s' --no-tag && pnpm publish",
		"release:beta": "pnpm release --tag beta",
		"release:alpha": "pnpm release --tag alpha",
		"clean": "rimraf ./dist && rimraf ./node_modules"
		}
		}

dist/index.d.mts

dist/index.mjs

Sorry, the diff of this file is not supported yet

@oku-ui/primitive - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics