@wirekyt/vue 0.0.1 → 0.0.2

package/dist/use-presence-CtEY6ZT8.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require("./rolldown-runtime-DakpK96I.cjs");
+const require_utils = require("./utils-XrBZd2Yk.cjs");
+let vue = require("vue");
+let _wirekyt_dom_machines_presence = require("@wirekyt/dom/machines/presence");
+_wirekyt_dom_machines_presence = require_rolldown_runtime.__toESM(_wirekyt_dom_machines_presence, 1);
+//#region src/components/presence/use-presence.ts
+const usePresence = (props, emit) => {
+	const wasEverPresent = (0, vue.ref)(false);
+	const nodeRef = (0, vue.ref)(null);
+	const machineProps = (0, vue.computed)(() => {
+		return {
+			present: (0, vue.toValue)(props).present,
+			onExitComplete: () => emit?.("exitComplete")
+		};
+	});
+	const service = require_utils.useMachine(_wirekyt_dom_machines_presence.machine, machineProps);
+	const api = (0, vue.computed)(() => _wirekyt_dom_machines_presence.connect(service, require_utils.normalizeProps));
+	(0, vue.watch)(() => api.value.present, () => {
+		if (api.value.present) wasEverPresent.value = true;
+	});
+	(0, vue.watch)(nodeRef, () => {
+		if (nodeRef.value) {
+			const node = nodeRef.value.$el ? nodeRef.value.$el : nodeRef.value;
+			if (node) api.value.setNode(node);
+		} else {
+			service.refs.set("node", null);
+			service.refs.set("styles", null);
+		}
+	});
+	return (0, vue.computed)(() => {
+		const localProps = (0, vue.toValue)(props);
+		return {
+			present: api.value.present,
+			unmounted: !api.value.present && !wasEverPresent.value && localProps.lazyMount || localProps?.unmountOnExit && !api.value?.present && wasEverPresent.value,
+			presenceProps: {
+				ref: nodeRef,
+				hidden: !api.value.present,
+				"data-state": api.value.skip && localProps.skipAnimationOnMount ? void 0 : localProps?.present ? "open" : "closed"
+			}
+		};
+	});
+};
+//#endregion
+Object.defineProperty(exports, "usePresence", {
+	enumerable: true,
+	get: function() {
+		return usePresence;
+	}
+});

package/dist/use-presence-DkGU_j9h.d.ts

@@ -0,0 +1,22 @@
+import { t as RootEmits } from "./types-rSRkzyd6.js";
+import { i as EmitFn$1, o as Optional } from "./index-BSoF1D-v.js";
+import { MaybeRef } from "vue";
+import * as presence from "@wirekyt/dom/machines/presence";
+//#region src/components/presence/use-presence.d.ts
+interface UsePresenceProps extends Optional<presence.Props, "present"> {
+  lazyMount?: boolean;
+  unmountOnExit?: boolean;
+  skipAnimationOnMount?: boolean;
+}
+type UsePresenceReturn = ReturnType<typeof usePresence>;
+declare const usePresence: (props: MaybeRef<UsePresenceProps>, emit?: EmitFn$1<RootEmits>) => import("vue").ComputedRef<{
+  present: boolean;
+  unmounted: boolean | undefined;
+  presenceProps: {
+    ref: import("vue").Ref<any, any>;
+    hidden: boolean;
+    "data-state": string | undefined;
+  };
+}>;
+//#endregion
+export { UsePresenceReturn as n, usePresence as r, UsePresenceProps as t };

package/dist/use-presence-oNdFU2c2.js

@@ -0,0 +1,42 @@
+import { c as normalizeProps$1, s as useMachine } from "./utils-D95V66v9.js";
+import { computed, ref, toValue, watch } from "vue";
+import * as presence from "@wirekyt/dom/machines/presence";
+//#region src/components/presence/use-presence.ts
+const usePresence = (props, emit) => {
+	const wasEverPresent = ref(false);
+	const nodeRef = ref(null);
+	const machineProps = computed(() => {
+		return {
+			present: toValue(props).present,
+			onExitComplete: () => emit?.("exitComplete")
+		};
+	});
+	const service = useMachine(presence.machine, machineProps);
+	const api = computed(() => presence.connect(service, normalizeProps$1));
+	watch(() => api.value.present, () => {
+		if (api.value.present) wasEverPresent.value = true;
+	});
+	watch(nodeRef, () => {
+		if (nodeRef.value) {
+			const node = nodeRef.value.$el ? nodeRef.value.$el : nodeRef.value;
+			if (node) api.value.setNode(node);
+		} else {
+			service.refs.set("node", null);
+			service.refs.set("styles", null);
+		}
+	});
+	return computed(() => {
+		const localProps = toValue(props);
+		return {
+			present: api.value.present,
+			unmounted: !api.value.present && !wasEverPresent.value && localProps.lazyMount || localProps?.unmountOnExit && !api.value?.present && wasEverPresent.value,
+			presenceProps: {
+				ref: nodeRef,
+				hidden: !api.value.present,
+				"data-state": api.value.skip && localProps.skipAnimationOnMount ? void 0 : localProps?.present ? "open" : "closed"
+			}
+		};
+	});
+};
+//#endregion
+export { usePresence as t };

package/dist/utils-D95V66v9.js

@@ -0,0 +1,548 @@
+import { Fragment, camelize, cloneVNode, computed, defineComponent, getCurrentInstance, inject, nextTick, onBeforeUnmount, onMounted, onUnmounted, provide, readonly, ref, shallowRef, toHandlerKey, toRef, toValue, watch } from "vue";
+import { INIT_STATE, MachineStatus, createScope, findTransition, getExitEnterStates, hasTag, matchesState, mergeProps as mergeProps$1, resolveStateValue } from "@wirekyt/dom";
+import { createNormalizer } from "@wirekyt/dom/types";
+import { callAll, compact, ensure, isEqual, isFunction, isString, toArray, warn } from "@wirekyt/dom/utils";
+//#region src/utils/create-context.ts
+const createContext = (id) => {
+	const contextId = Symbol(id);
+	const provider = (value) => provide(contextId, value);
+	const consumer = (fallback) => inject(contextId, fallback);
+	return [
+		provider,
+		consumer,
+		contextId
+	];
+};
+//#endregion
+//#region src/utils/use-emits-as-props.ts
+function useEmitAsProps(emit) {
+	const vm = getCurrentInstance();
+	const events = vm?.type.emits;
+	const result = {};
+	if (!events?.length) console.warn(`No emitted event found. Please check component: ${vm?.type.__name}`);
+	for (const event of events) result[toHandlerKey(camelize(event))] = (...arg) => emit(event, ...arg);
+	return result;
+}
+//#endregion
+//#region src/utils/unref-element.ts
+function unrefElement(elRef) {
+	const plain = toValue(elRef);
+	return plain?.$el ?? plain;
+}
+//#endregion
+//#region src/utils/use-forward-expose.ts
+const isElement = (el) => Object.prototype.hasOwnProperty.call(el, "nodeName") && typeof el.nodeName === "string";
+function useForwardExpose() {
+	const instance = getCurrentInstance();
+	const currentRef = ref();
+	const currentElement = computed(() => {
+		return ["#text", "#comment"].includes(currentRef.value?.$el.nodeName) ? currentRef.value?.$el.nextElementSibling : unrefElement(currentRef);
+	});
+	const localExpose = Object.assign({}, instance.exposed);
+	const ret = {};
+	for (const key in instance.props) Object.defineProperty(ret, key, {
+		enumerable: true,
+		configurable: true,
+		get: () => instance.props[key]
+	});
+	if (Object.keys(localExpose).length > 0) for (const key in localExpose) Object.defineProperty(ret, key, {
+		enumerable: true,
+		configurable: true,
+		get: () => localExpose[key]
+	});
+	Object.defineProperty(ret, "$el", {
+		enumerable: true,
+		configurable: true,
+		get: () => instance.vnode.el
+	});
+	instance.exposed = ret;
+	function forwardRef(ref) {
+		currentRef.value = ref;
+		if (!ref) return;
+		Object.defineProperty(ret, "$el", {
+			enumerable: true,
+			configurable: true,
+			get: () => isElement(ref) ? ref : ref.$el
+		});
+		instance.exposed = ret;
+	}
+	return {
+		forwardRef,
+		currentRef,
+		currentElement
+	};
+}
+//#endregion
+//#region src/utils/use-forward-props.ts
+function useForwardProps(props) {
+	const vm = getCurrentInstance();
+	const propOptions = vm?.type.props ?? {};
+	const defaultProps = Object.keys(propOptions).reduce((prev, curr) => {
+		const defaultValue = propOptions[curr].default;
+		if (defaultValue !== void 0) prev[curr] = defaultValue;
+		return prev;
+	}, {});
+	const refProps = toRef(props);
+	return computed(() => {
+		const preservedProps = {};
+		const assignedProps = vm?.vnode.props ?? {};
+		Object.keys(assignedProps).forEach((key) => {
+			preservedProps[camelize(key)] = assignedProps[key];
+		});
+		return Object.keys({
+			...defaultProps,
+			...preservedProps
+		}).reduce((prev, curr) => {
+			if (refProps.value[curr] !== void 0) prev[curr] = refProps.value[curr];
+			return prev;
+		}, {});
+	});
+}
+//#endregion
+//#region src/utils/use-forward-props-emits.ts
+function useForwardPropsEmits(props, emit) {
+	const parsedProps = useForwardProps(props);
+	const emitsAsProps = emit ? useEmitAsProps(emit) : {};
+	return computed(() => ({
+		...parsedProps.value,
+		...emitsAsProps
+	}));
+}
+//#endregion
+//#region src/core/normalize-props.ts
+function toCase(txt) {
+	return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+}
+const propMap = {
+	htmlFor: "for",
+	className: "class",
+	onDoubleClick: "onDblclick",
+	onChange: "onInput",
+	onFocus: "onFocusin",
+	onBlur: "onFocusout",
+	defaultValue: "value",
+	defaultChecked: "checked"
+};
+const preserveKeys = "viewBox,className,preserveAspectRatio,fillRule,clipPath,clipRule,strokeWidth,strokeLinecap,strokeLinejoin,strokeDasharray,strokeDashoffset,strokeMiterlimit".split(",");
+function toVueProp(prop) {
+	if (prop in propMap) return propMap[prop];
+	if (prop.startsWith("on")) return `on${toCase(prop.substr(2))}`;
+	if (preserveKeys.includes(prop)) return prop;
+	return prop.toLowerCase();
+}
+const normalizeProps$1 = createNormalizer((props) => {
+	const normalized = {};
+	for (const key in props) {
+		const value = props[key];
+		if (key === "children") {
+			if (typeof value === "string") normalized["innerHTML"] = value;
+			else if (process.env.NODE_ENV !== "production" && value != null) console.warn("[Vue Normalize Prop] : avoid passing non-primitive value as `children`");
+		} else normalized[toVueProp(key)] = props[key];
+	}
+	return normalized;
+});
+//#endregion
+//#region src/core/bindable.ts
+function bindable(props) {
+	const initial = props().defaultValue ?? props().value;
+	const eq = props().isEqual ?? Object.is;
+	const v = shallowRef(initial);
+	const controlled = computed(() => props().value !== void 0);
+	return {
+		initial,
+		ref: shallowRef(controlled.value ? props().value : v.value),
+		get() {
+			return controlled.value ? props().value : v.value;
+		},
+		set(val) {
+			const prev = controlled.value ? props().value : v.value;
+			const next = isFunction(val) ? val(prev) : val;
+			if (props().debug) console.log(`[bindable > ${props().debug}] setValue`, {
+				next,
+				prev
+			});
+			if (!controlled.value) v.value = next;
+			if (!eq(next, prev)) props().onChange?.(next, prev);
+		},
+		invoke(nextValue, prevValue) {
+			props().onChange?.(nextValue, prevValue);
+		},
+		hash(value) {
+			return props().hash?.(value) ?? String(value);
+		}
+	};
+}
+bindable.cleanup = (fn) => {
+	onUnmounted(() => fn());
+};
+bindable.ref = (defaultValue) => {
+	let value = defaultValue;
+	return {
+		get: () => value,
+		set: (next) => {
+			value = next;
+		}
+	};
+};
+//#endregion
+//#region src/core/refs.ts
+function useRefs(refs) {
+	const ref = { current: refs };
+	return {
+		get(key) {
+			return ref.current[key];
+		},
+		set(key, value) {
+			ref.current[key] = value;
+		}
+	};
+}
+//#endregion
+//#region src/core/track.ts
+const useTrack = (deps, effect) => {
+	watch(() => deps.map((d) => d()), (current, previous) => {
+		let changed = false;
+		for (let i = 0; i < current.length; i++) if (!isEqual(previous[i], toValue(current[i]))) {
+			changed = true;
+			break;
+		}
+		if (changed) effect();
+	});
+};
+//#endregion
+//#region src/core/machine.ts
+function useMachine(machine, userProps = {}) {
+	const scope = computed(() => {
+		const { id, ids, getRootNode } = toValue(userProps);
+		return createScope({
+			id,
+			ids,
+			getRootNode
+		});
+	});
+	const debug = (...args) => {
+		if (machine.debug) console.log(...args);
+	};
+	const prop = useProp(computed(() => machine.props?.({
+		props: compact(toValue(userProps)),
+		get scope() {
+			return scope.value;
+		}
+	}) ?? toValue(userProps)));
+	const context = machine.context?.({
+		prop,
+		bindable,
+		get scope() {
+			return scope.value;
+		},
+		flush,
+		getContext() {
+			return ctx;
+		},
+		getComputed() {
+			return computed$1;
+		},
+		getRefs() {
+			return refs;
+		},
+		getEvent() {
+			return getEvent();
+		}
+	});
+	const ctx = {
+		get(key) {
+			return context[key]?.get();
+		},
+		set(key, value) {
+			context[key]?.set(value);
+		},
+		initial(key) {
+			return context[key]?.initial;
+		},
+		hash(key) {
+			const current = context[key]?.get();
+			return context[key]?.hash(current);
+		}
+	};
+	let effects = /* @__PURE__ */ new Map();
+	let transitionRef = null;
+	let previousEventRef = { current: null };
+	let eventRef = { current: { type: "" } };
+	const getEvent = () => ({
+		...eventRef.current,
+		current() {
+			return eventRef.current;
+		},
+		previous() {
+			return previousEventRef.current;
+		}
+	});
+	const getState = () => ({
+		...state,
+		matches(...values) {
+			const currentState = state.get();
+			return values.some((value) => matchesState(currentState, value));
+		},
+		hasTag(tag) {
+			return hasTag(machine, state.get(), tag);
+		}
+	});
+	const refs = useRefs(machine.refs?.({
+		prop,
+		context: ctx
+	}) ?? {});
+	const getParams = () => ({
+		state: getState(),
+		context: ctx,
+		event: getEvent(),
+		prop,
+		send,
+		action,
+		guard,
+		track: useTrack,
+		refs,
+		computed: computed$1,
+		flush,
+		get scope() {
+			return scope.value;
+		},
+		choose
+	});
+	const action = (keys) => {
+		const strs = isFunction(keys) ? keys(getParams()) : keys;
+		if (!strs) return;
+		const fns = strs.map((s) => {
+			const fn = machine.implementations?.actions?.[s];
+			if (!fn) warn(`[wirekyt] No implementation found for action "${JSON.stringify(s)}"`);
+			return fn;
+		});
+		for (const fn of fns) fn?.(getParams());
+	};
+	const guard = (str) => {
+		if (isFunction(str)) return str(getParams());
+		const fn = machine.implementations?.guards?.[str];
+		if (!fn) warn(`[wirekyt] No implementation found for guard "${JSON.stringify(str)}"`);
+		return fn?.(getParams());
+	};
+	const effect = (keys) => {
+		const strs = isFunction(keys) ? keys(getParams()) : keys;
+		if (!strs) return;
+		const fns = strs.map((s) => {
+			const fn = machine.implementations?.effects?.[s];
+			if (!fn) warn(`[wirekyt] No implementation found for effect "${JSON.stringify(s)}"`);
+			return fn;
+		});
+		const cleanups = [];
+		for (const fn of fns) {
+			const cleanup = fn?.(getParams());
+			if (cleanup) cleanups.push(cleanup);
+		}
+		return () => cleanups.forEach((fn) => fn?.());
+	};
+	const choose = (transitions) => {
+		return toArray(transitions).find((t) => {
+			let result = !t.guard;
+			if (isString(t.guard)) result = !!guard(t.guard);
+			else if (isFunction(t.guard)) result = t.guard(getParams());
+			return result;
+		});
+	};
+	const computed$1 = (key) => {
+		ensure(machine.computed, () => `[wirekyt] No computed object found on machine`);
+		const fn = machine.computed[key];
+		return fn({
+			context: ctx,
+			event: getEvent(),
+			prop,
+			refs,
+			get scope() {
+				return scope.value;
+			},
+			computed: computed$1
+		});
+	};
+	const state = bindable(() => ({
+		defaultValue: resolveStateValue(machine, machine.initialState({ prop })),
+		onChange(nextState, prevState) {
+			const { exiting, entering } = getExitEnterStates(machine, prevState, nextState, transitionRef?.reenter);
+			exiting.forEach((item) => {
+				effects.get(item.path)?.();
+				effects.delete(item.path);
+			});
+			exiting.forEach((item) => {
+				action(item.state?.exit);
+			});
+			action(transitionRef?.actions);
+			entering.forEach((item) => {
+				const cleanup = effect(item.state?.effects);
+				if (cleanup) {
+					const existing = effects.get(item.path);
+					effects.set(item.path, existing ? callAll(existing, cleanup) : cleanup);
+				}
+			});
+			if (prevState === INIT_STATE) {
+				action(machine.entry);
+				const cleanup = effect(machine.effects);
+				if (cleanup) {
+					const existing = effects.get(INIT_STATE);
+					effects.set(INIT_STATE, existing ? callAll(existing, cleanup) : cleanup);
+				}
+			}
+			entering.forEach((item) => {
+				action(item.state?.entry);
+			});
+		}
+	}));
+	let status = MachineStatus.NotStarted;
+	let pendingEvents = [];
+	onMounted(() => {
+		const started = status === MachineStatus.Started;
+		status = MachineStatus.Started;
+		debug(started ? "rehydrating..." : "initializing...");
+		state.invoke(state.initial, INIT_STATE);
+		const events = pendingEvents;
+		pendingEvents = [];
+		for (const event of events) send(event);
+	});
+	onBeforeUnmount(() => {
+		status = MachineStatus.Stopped;
+		pendingEvents = [];
+		debug("unmounting...");
+		const fns = effects.values();
+		for (const fn of fns) fn?.();
+		effects = /* @__PURE__ */ new Map();
+		action(machine.exit);
+	});
+	const send = (event) => {
+		if (status !== MachineStatus.Started) {
+			pendingEvents.push(event);
+			return;
+		}
+		previousEventRef.current = eventRef.current;
+		eventRef.current = event;
+		let currentState = state.get();
+		const { transitions, source } = findTransition(machine, currentState, event.type);
+		const transition = choose(transitions);
+		if (!transition) return;
+		transitionRef = transition;
+		const target = resolveStateValue(machine, transition.target ?? currentState, source);
+		debug("transition", event.type, transition.target || currentState, `(${transition.actions})`);
+		if (target !== currentState) state.set(target);
+		else if (transition.reenter) state.invoke(currentState, currentState);
+		else action(transition.actions);
+	};
+	machine.watch?.(getParams());
+	return {
+		state: getState(),
+		send,
+		context: ctx,
+		prop,
+		get scope() {
+			return scope.value;
+		},
+		refs,
+		computed: computed$1,
+		event: getEvent(),
+		getStatus: () => status
+	};
+}
+function useProp(valueRef) {
+	return function get(key) {
+		return valueRef.value[key];
+	};
+}
+const flush = (fn) => {
+	nextTick().then(() => {
+		fn();
+	});
+};
+//#endregion
+//#region src/core/use-sync-external-store.ts
+function useSyncExternalStore(subscribe, getSnapshot, _getServerSnapshot) {
+	const snapshot = shallowRef(getSnapshot());
+	let unsubscribe;
+	onMounted(() => {
+		snapshot.value = getSnapshot();
+		unsubscribe = subscribe(() => {
+			snapshot.value = getSnapshot();
+		});
+	});
+	onUnmounted(() => {
+		unsubscribe?.();
+	});
+	return readonly(snapshot);
+}
+//#endregion
+//#region src/utils/dynamic.ts
+const Dynamic = defineComponent({
+	name: "Dynamic",
+	inheritAttrs: false,
+	setup(_, { attrs, slots }) {
+		return () => {
+			if (!slots.default) return null;
+			const children = renderSlotFragments(slots.default());
+			const [firstChildren, ...otherChildren] = children;
+			if (firstChildren && Object.keys(attrs).length > 0) {
+				delete firstChildren.props?.ref;
+				const mergedProps = mergeProps$1(attrs, firstChildren.props ?? {});
+				const cloned = cloneVNode(firstChildren, mergedProps);
+				for (const prop in mergedProps) if (prop.startsWith("on")) {
+					cloned.props ||= {};
+					cloned.props[prop] = mergedProps[prop];
+				}
+				return children.length === 1 ? cloned : [cloned, ...otherChildren];
+			}
+			return children;
+		};
+	}
+});
+function renderSlotFragments(children) {
+	if (!children) return [];
+	return children.flatMap((child) => {
+		if (child.type === Fragment) return renderSlotFragments(child.children);
+		return [child];
+	});
+}
+//#endregion
+//#region src/utils/use-render-strategy.ts
+const [RenderStrategyPropsProvider, useRenderStrategyProps] = createContext("RenderStrategyProps");
+//#endregion
+//#region src/utils/use-v-model.ts
+function useVModel(props, key, emit, options = {}) {
+	const { passive = false, eventName, defaultValue } = options;
+	const vm = getCurrentInstance();
+	const _emit = emit || vm?.emit || vm?.$emit?.bind(vm) || vm?.proxy?.$emit?.bind(vm?.proxy);
+	const prop = key || "modelValue";
+	const getValue = () => props[prop] ?? defaultValue;
+	const triggerEmit = (value) => {
+		if (!eventName) _emit(eventName || `update:${prop.toString()}`, value);
+		else for (const event of eventName) _emit(event, value);
+	};
+	if (passive) {
+		const proxy = ref(getValue());
+		let isUpdating = false;
+		watch(() => props[prop], (v) => {
+			if (!isUpdating) {
+				isUpdating = true;
+				proxy.value = v;
+				nextTick(() => {
+					isUpdating = false;
+				});
+			}
+		});
+		watch(proxy, (v) => {
+			if (!isUpdating && v !== props[prop]) triggerEmit(v);
+		});
+		return proxy;
+	}
+	return computed({
+		get() {
+			return getValue();
+		},
+		set(value) {
+			triggerEmit(value);
+		}
+	});
+}
+//#endregion
+export { mergeProps$1 as a, normalizeProps$1 as c, useForwardExpose as d, unrefElement as f, Dynamic as i, useForwardPropsEmits as l, createContext as m, RenderStrategyPropsProvider as n, useSyncExternalStore as o, useEmitAsProps as p, useRenderStrategyProps as r, useMachine as s, useVModel as t, useForwardProps as u };