duck-vue-components 0.0.0

package/dist/controls/affix.d.cts

@@ -0,0 +1,2 @@
+import { t as affix_d_exports } from "../index-C-uY4885.cjs";
+export { affix_d_exports as RwAffix };

package/dist/controls/affix.d.ts

@@ -0,0 +1,2 @@
+import { t as affix_d_exports } from "../index-C5SJLWEN.js";
+export { affix_d_exports as RwAffix };

package/dist/controls/affix.js

@@ -0,0 +1,2 @@
+import { t as affix_exports } from "../affix-D9EM8_Um.js";
+export { affix_exports as RwAffix };

package/dist/controls/button.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_button = require("../button-CGv1WHzT.cjs");
+Object.defineProperty(exports, "RwButton", {
+	enumerable: true,
+	get: function() {
+		return require_button.button_exports;
+	}
+});

package/dist/controls/button.js

@@ -0,0 +1,2 @@
+import { t as button_exports } from "../button-tOWSPPxz.js";
+export { button_exports as RwButton };

package/dist/controls.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_MyButton = require("./MyButton-C1krVCi6.cjs");
+const require_button = require("./button-CGv1WHzT.cjs");
+const require_affix = require("./affix-CYU-9qMr.cjs");
+require("./packages/controls.cjs");
+exports.MyButton = require_MyButton.MyButton_default;
+Object.defineProperty(exports, "RwAffix", {
+	enumerable: true,
+	get: function() {
+		return require_affix.affix_exports;
+	}
+});
+Object.defineProperty(exports, "RwButton", {
+	enumerable: true,
+	get: function() {
+		return require_button.button_exports;
+	}
+});

package/dist/controls.d.cts

@@ -0,0 +1,10 @@
+import { t as _default } from "./index-PhthUD7x.cjs";
+import { t as affix_d_exports } from "./index-C-uY4885.cjs";
+import { t as button_d_exports } from "./index-CSvc8L11.cjs";
+
+//#region src/packages/controls/index.d.ts
+declare namespace index_d_exports {
+  export { _default as MyButton, affix_d_exports as RwAffix, button_d_exports as RwButton };
+}
+//#endregion
+export { _default as MyButton, affix_d_exports as RwAffix, button_d_exports as RwButton, index_d_exports as t };

package/dist/controls.d.ts

@@ -0,0 +1,10 @@
+import { t as _default } from "./index-BtOBjeH7.js";
+import { t as affix_d_exports } from "./index-C5SJLWEN.js";
+import { t as button_d_exports } from "./index-CeemHBNT.js";
+
+//#region src/packages/controls/index.d.ts
+declare namespace index_d_exports {
+  export { _default as MyButton, affix_d_exports as RwAffix, button_d_exports as RwButton };
+}
+//#endregion
+export { _default as MyButton, affix_d_exports as RwAffix, button_d_exports as RwButton, index_d_exports as t };

package/dist/controls.js

@@ -0,0 +1,5 @@
+import { t as MyButton_default } from "./MyButton-C7riFwH6.js";
+import { t as button_exports } from "./button-tOWSPPxz.js";
+import { t as affix_exports } from "./affix-D9EM8_Um.js";
+import "./packages/controls.js";
+export { MyButton_default as MyButton, affix_exports as RwAffix, button_exports as RwButton };

package/dist/dom-CllENWMY.js

@@ -0,0 +1,346 @@
+import { E as isStringNumber, T as isString$1, b as isNumber, i as entriesOf, k as isWindow, s as keysOf, v as isFunction, x as isObject$1 } from "./objects-CLXPNOUW.js";
+import { isClient, isIOS } from "@vueuse/core";
+import { camelize, capitalize, hyphenate, hyphenate as kebabCase } from "@vue/shared";
+//#region src/packages/utils/dom/aria.ts
+const FOCUSABLE_ELEMENT_SELECTORS = `a[href],button:not([disabled]),button:not([hidden]),:not([tabindex="-1"]),input:not([disabled]),input:not([type="hidden"]),select:not([disabled]),textarea:not([disabled])`;
+/**
+* Determine if the testing element is visible on screen no matter if its on the viewport or not
+*/
+const isVisible = (element) => {
+	if (process?.env?.NODE_ENV === "test") return true;
+	return getComputedStyle(element).position === "fixed" ? false : element.offsetParent !== null;
+};
+const obtainAllFocusableElements = (element) => {
+	return Array.from(element.querySelectorAll(FOCUSABLE_ELEMENT_SELECTORS)).filter((item) => isFocusable(item) && isVisible(item));
+};
+/**
+* @desc Determine if target element is focusable
+* @param element {HTMLElement}
+* @returns {Boolean} true if it is focusable
+*/
+const isFocusable = (element) => {
+	if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute("tabIndex") !== null) return true;
+	if (element.tabIndex < 0 || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") return false;
+	switch (element.nodeName) {
+		case "A": return !!element.href && element.rel !== "ignore";
+		case "INPUT": return !(element.type === "hidden" || element.type === "file");
+		case "BUTTON":
+		case "SELECT":
+		case "TEXTAREA": return true;
+		default: return false;
+	}
+};
+/**
+* @desc Set Attempt to set focus on the current node.
+* @param element
+*          The node to attempt to focus on.
+* @returns
+*  true if element is focused.
+*/
+const attemptFocus = (element) => {
+	if (!isFocusable(element)) return false;
+	element.focus?.();
+	return document.activeElement === element;
+};
+/**
+* Trigger an event
+* mouseenter, mouseleave, mouseover, keyup, change, click, etc.
+* @param  {HTMLElement} elm
+* @param  {String} name
+* @param  {*} opts
+*/
+const triggerEvent = function(elm, name, ...opts) {
+	let eventName;
+	if (name.includes("mouse") || name.includes("click")) eventName = "MouseEvents";
+	else if (name.includes("key")) eventName = "KeyboardEvent";
+	else eventName = "HTMLEvents";
+	const evt = document.createEvent(eventName);
+	evt.initEvent(name, ...opts);
+	elm.dispatchEvent(evt);
+	return elm;
+};
+const isLeaf = (el) => !el.getAttribute("aria-owns");
+const getSibling = (el, distance, elClass) => {
+	const { parentNode } = el;
+	if (!parentNode) return null;
+	const siblings = parentNode.querySelectorAll(elClass);
+	return siblings[Array.prototype.indexOf.call(siblings, el) + distance] || null;
+};
+const focusNode = (el) => {
+	if (!el) return;
+	el.focus();
+	!isLeaf(el) && el.click();
+};
+//#endregion
+//#region src/packages/utils/dom/event.ts
+const composeEventHandlers = (theirsHandler, oursHandler, { checkForDefaultPrevented = true } = {}) => {
+	const handleEvent = (event) => {
+		const shouldPrevent = theirsHandler?.(event);
+		if (checkForDefaultPrevented === false || !shouldPrevent) return oursHandler?.(event);
+	};
+	return handleEvent;
+};
+const whenMouse = (handler) => {
+	return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
+};
+//#endregion
+//#region src/packages/utils/browser.ts
+const isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
+const loadScript = (src, options = {}) => {
+	const { async = true, type = "text/javascript", defer = true } = options;
+	return new Promise((resolve, reject) => {
+		const script = document.createElement("script");
+		script.src = src;
+		script.type = type;
+		script.async = async;
+		script.defer = defer;
+		script.onload = () => {
+			resolve();
+		};
+		script.onerror = () => {
+			reject();
+		};
+		document.body.appendChild(script);
+	});
+};
+//#endregion
+//#region src/packages/utils/dom/position.ts
+const isInContainer = (el, container) => {
+	if (!isClient || !el || !container) return false;
+	const elRect = el.getBoundingClientRect();
+	let containerRect;
+	if (container instanceof Element) containerRect = container.getBoundingClientRect();
+	else containerRect = {
+		top: 0,
+		right: window.innerWidth,
+		bottom: window.innerHeight,
+		left: 0
+	};
+	return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
+};
+const getOffsetTop = (el) => {
+	let offset = 0;
+	let parent = el;
+	while (parent) {
+		offset += parent.offsetTop;
+		parent = parent.offsetParent;
+	}
+	return offset;
+};
+const getOffsetTopDistance = (el, containerEl) => {
+	return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
+};
+const getClientXY = (event) => {
+	let clientX;
+	let clientY;
+	if (event.type === "touchend") {
+		clientY = event.changedTouches[0].clientY;
+		clientX = event.changedTouches[0].clientX;
+	} else if (event.type.startsWith("touch")) {
+		clientY = event.touches[0].clientY;
+		clientX = event.touches[0].clientX;
+	} else {
+		clientY = event.clientY;
+		clientX = event.clientX;
+	}
+	return {
+		clientX,
+		clientY
+	};
+};
+//#endregion
+//#region src/packages/utils/easings.ts
+function easeInOutCubic(t, b, c, d) {
+	const cc = c - b;
+	t /= d / 2;
+	if (t < 1) return cc / 2 * t * t * t + b;
+	return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}
+//#endregion
+//#region src/packages/utils/raf.ts
+const rAF = (fn) => isClient ? window.requestAnimationFrame(fn) : setTimeout(fn, 16);
+const cAF = (handle) => isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);
+//#endregion
+//#region src/packages/utils/strings.ts
+/**
+* fork from {@link https://github.com/sindresorhus/escape-string-regexp}
+*/
+const escapeStringRegexp = (string = "") => string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+const capitalize$1 = (str) => capitalize(str);
+//#endregion
+//#region src/packages/utils/error.ts
+var ElementPlusError = class extends Error {
+	constructor(m) {
+		super(m);
+		this.name = "ElementPlusError";
+	}
+};
+function throwError(scope, m) {
+	throw new ElementPlusError(`[${scope}] ${m}`);
+}
+function debugWarn(scope, message) {
+	if (process?.env?.NODE_ENV !== "production") {
+		const error = isString$1(scope) ? new ElementPlusError(`[${scope}] ${message}`) : scope;
+		console.warn(error);
+	}
+}
+//#endregion
+//#region src/packages/utils/dom/style.ts
+const SCOPE = "utils/dom/style";
+const classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
+const hasClass = (el, cls) => {
+	if (!el || !cls) return false;
+	if (cls.includes(" ")) throw new Error("className should not contain space.");
+	return el.classList.contains(cls);
+};
+const addClass = (el, cls) => {
+	if (!el || !cls.trim()) return;
+	el.classList.add(...classNameToArray(cls));
+};
+const removeClass = (el, cls) => {
+	if (!el || !cls.trim()) return;
+	el.classList.remove(...classNameToArray(cls));
+};
+const getStyle = (element, styleName) => {
+	if (!isClient || !element || !styleName) return "";
+	let key = camelize(styleName);
+	if (key === "float") key = "cssFloat";
+	try {
+		const style = element.style[key];
+		if (style) return style;
+		const computed = document.defaultView?.getComputedStyle(element, "");
+		return computed ? computed[key] : "";
+	} catch {
+		return element.style[key];
+	}
+};
+const setStyle = (element, styleName, value) => {
+	if (!element || !styleName) return;
+	if (isObject$1(styleName)) entriesOf(styleName).forEach(([prop, value]) => setStyle(element, prop, value));
+	else {
+		const key = camelize(styleName);
+		element.style[key] = value;
+	}
+};
+const removeStyle = (element, style) => {
+	if (!element || !style) return;
+	if (isObject$1(style)) keysOf(style).forEach((prop) => removeStyle(element, prop));
+	else setStyle(element, style, "");
+};
+function addUnit(value, defaultUnit = "px") {
+	if (!value) return "";
+	if (isNumber(value) || isStringNumber(value)) return `${value}${defaultUnit}`;
+	else if (isString$1(value)) return value;
+	debugWarn(SCOPE, "binding value must be a string or number");
+}
+//#endregion
+//#region src/packages/utils/dom/scroll.ts
+const isScroll = (el, isVertical) => {
+	if (!isClient) return false;
+	const key = {
+		undefined: "overflow",
+		true: "overflow-y",
+		false: "overflow-x"
+	}[String(isVertical)];
+	const overflow = getStyle(el, key);
+	return [
+		"scroll",
+		"auto",
+		"overlay"
+	].some((s) => overflow.includes(s));
+};
+const getScrollContainer = (el, isVertical) => {
+	if (!isClient) return;
+	let parent = el;
+	while (parent) {
+		if ([
+			window,
+			document,
+			document.documentElement
+		].includes(parent)) return window;
+		if (isScroll(parent, isVertical)) return parent;
+		parent = parent.parentNode;
+	}
+	return parent;
+};
+let scrollBarWidth;
+const getScrollBarWidth = (namespace) => {
+	if (!isClient) return 0;
+	if (scrollBarWidth !== void 0) return scrollBarWidth;
+	const outer = document.createElement("div");
+	outer.className = `${namespace}-scrollbar__wrap`;
+	outer.style.visibility = "hidden";
+	outer.style.width = "100px";
+	outer.style.position = "absolute";
+	outer.style.top = "-9999px";
+	document.body.appendChild(outer);
+	const widthNoScroll = outer.offsetWidth;
+	outer.style.overflow = "scroll";
+	const inner = document.createElement("div");
+	inner.style.width = "100%";
+	outer.appendChild(inner);
+	const widthWithScroll = inner.offsetWidth;
+	outer.parentNode?.removeChild(outer);
+	scrollBarWidth = widthNoScroll - widthWithScroll;
+	return scrollBarWidth;
+};
+/**
+* Scroll with in the container element, positioning the **selected** element at the top
+* of the container
+*/
+function scrollIntoView(container, selected) {
+	if (!isClient) return;
+	if (!selected) {
+		container.scrollTop = 0;
+		return;
+	}
+	const offsetParents = [];
+	let pointer = selected.offsetParent;
+	while (pointer !== null && container !== pointer && container.contains(pointer)) {
+		offsetParents.push(pointer);
+		pointer = pointer.offsetParent;
+	}
+	const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
+	const bottom = top + selected.offsetHeight;
+	const viewRectTop = container.scrollTop;
+	const viewRectBottom = viewRectTop + container.clientHeight;
+	if (top < viewRectTop) container.scrollTop = top;
+	else if (bottom > viewRectBottom) container.scrollTop = bottom - container.clientHeight;
+}
+function animateScrollTo(container, from, to, duration, callback) {
+	const startTime = Date.now();
+	let handle;
+	const scroll = () => {
+		const time = Date.now() - startTime;
+		const nextScrollTop = easeInOutCubic(time > duration ? duration : time, from, to, duration);
+		if (isWindow(container)) container.scrollTo(window.pageXOffset, nextScrollTop);
+		else container.scrollTop = nextScrollTop;
+		if (time < duration) handle = rAF(scroll);
+		else if (isFunction(callback)) callback();
+	};
+	scroll();
+	return () => {
+		handle && cAF(handle);
+	};
+}
+const getScrollElement = (target, container) => {
+	if (isWindow(container)) return target.ownerDocument.documentElement;
+	return container;
+};
+const getScrollTop = (container) => {
+	if (isWindow(container)) return window.scrollY;
+	return container.scrollTop;
+};
+//#endregion
+//#region src/packages/utils/dom/element.ts
+const getElement = ((target) => {
+	if (!isClient || target === "") return null;
+	if (isString$1(target)) try {
+		return document.querySelector(target);
+	} catch {
+		return null;
+	}
+	return target;
+});
+//#endregion
+export { isInContainer as A, isFocusable as B, kebabCase as C, getClientXY as D, easeInOutCubic as E, composeEventHandlers as F, isVisible as H, whenMouse as I, attemptFocus as L, isFirefox as M, isIOS as N, getOffsetTop as O, loadScript as P, focusNode as R, hyphenate as S, rAF as T, obtainAllFocusableElements as U, isLeaf as V, triggerEvent as W, debugWarn as _, getScrollElement as a, capitalize$1 as b, scrollIntoView as c, classNameToArray as d, getStyle as f, setStyle as g, removeStyle as h, getScrollContainer as i, isClient as j, getOffsetTopDistance as k, addClass as l, removeClass as m, animateScrollTo as n, getScrollTop as o, hasClass as p, getScrollBarWidth as r, isScroll as s, getElement as t, addUnit as u, throwError as v, cAF as w, escapeStringRegexp as x, camelize as y, getSibling as z };