@sprawlify/vue 0.0.63 → 0.0.65

package/dist/index.js

@@ -1,337 +1,52 @@
-import { INIT_STATE, MachineStatus, createScope, mergeProps } from "@sprawlify/primitives/core";
-import { createNormalizer } from "@sprawlify/primitives/types";
-import { compact, ensure, isEqual, isFunction, isString, toArray, warn } from "@sprawlify/primitives/utils";
-import { computed, nextTick, onBeforeUnmount, onMounted, onUnmounted, shallowRef, toValue, watch } from "vue";
+import { a as DEFAULT_LOCALE, c as DEFAULT_ENVIRONMENT, d as mergeProps, f as useMachine, i as locale_provider_default, l as useEnvironmentContext, n as useFilter, o as useLocaleContext, p as normalizeProps, r as useCollator, s as environment_provider_default, t as useForwardExpose, u as createContext } from "./use-forward-expose-BIk4OI3R.js";
+import { camelize, computed, getCurrentInstance, toHandlerKey, toRef } from "vue";
 
-//#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 = 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;
-		}
-	};
+//#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/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();
+//#region src/utils/use-forward-props.ts
+function useForwardProps(props) {
+	const vm = getCurrentInstance();
+	const defaultProps = Object.keys(vm?.type.props ?? {}).reduce((prev, curr) => {
+		const defaultValue = (vm?.type.props[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/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;
-	const previousEventRef = { current: null };
-	const 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.includes(currentState);
-		},
-		hasTag(tag) {
-			const currentState = state.get();
-			return !!machine.states[currentState]?.tags?.includes(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(`[sprawlify-js] 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());
-		return machine.implementations?.guards?.[str](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(`[sprawlify-js] 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, () => `[sprawlify-js] 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: machine.initialState({ prop }),
-		onChange(nextState, prevState) {
-			if (prevState) {
-				effects.get(prevState)?.();
-				effects.delete(prevState);
-			}
-			if (prevState) action(machine.states[prevState]?.exit);
-			action(transitionRef?.actions);
-			const cleanup = effect(machine.states[nextState]?.effects);
-			if (cleanup) effects.set(nextState, cleanup);
-			if (prevState === INIT_STATE) {
-				action(machine.entry);
-				const cleanup = effect(machine.effects);
-				if (cleanup) effects.set(INIT_STATE, cleanup);
-			}
-			action(machine.states[nextState]?.entry);
-		}
+//#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
 	}));
-	let status = MachineStatus.NotStarted;
-	onMounted(() => {
-		const started = status === MachineStatus.Started;
-		status = MachineStatus.Started;
-		debug(started ? "rehydrating..." : "initializing...");
-		state.invoke(state.initial, INIT_STATE);
-	});
-	onBeforeUnmount(() => {
-		status = MachineStatus.Stopped;
-		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) return;
-		previousEventRef.current = eventRef.current;
-		eventRef.current = event;
-		const currentState = state.get();
-		const transition = choose(machine.states[currentState].on?.[event.type] ?? machine.on?.[event.type]);
-		if (!transition) return;
-		transitionRef = transition;
-		const target = transition.target ?? currentState;
-		debug("transition", event.type, transition.target || currentState, `(${transition.actions})`);
-		const changed = target !== currentState;
-		if (changed) state.set(target);
-		else if (transition.reenter && !changed) 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
-export { mergeProps, normalizeProps, useMachine };
+export { DEFAULT_ENVIRONMENT, DEFAULT_LOCALE, environment_provider_default as EnvironmentProvider, locale_provider_default as LocaleProvider, createContext, mergeProps, normalizeProps, useCollator, useEmitAsProps, useEnvironmentContext, useFilter, useForwardExpose, useForwardProps, useForwardPropsEmits, useLocaleContext, useMachine };

package/dist/types-BQfkZGpL.d.ts

@@ -0,0 +1,30 @@
+import { Machine, MachineSchema, Service, mergeProps as mergeProps$1 } from "@sprawlify/primitives/core";
+import * as _sprawlify_primitives_types0 from "@sprawlify/primitives/types";
+import * as Vue from "vue";
+import { ComputedRef, Ref } from "vue";
+
+//#region src/core/normalize-props.d.ts
+type ReservedProps = {
+  key?: string | number | symbol | undefined;
+  ref?: Vue.VNodeRef | undefined;
+};
+type Attrs<T> = T & ReservedProps;
+type PropTypes = Vue.NativeElements & {
+  element: Attrs<Vue.HTMLAttributes>;
+  style: Vue.CSSProperties;
+};
+declare const normalizeProps$1: _sprawlify_primitives_types0.NormalizeProps<PropTypes>;
+//#endregion
+//#region src/core/machine.d.ts
+type MaybeRef$1<T> = T | Ref<T> | ComputedRef<T>;
+declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef$1<Partial<T["props"]>>): Service<T>;
+//#endregion
+//#region src/types.d.ts
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type Assign<T, U> = Omit<T, keyof U> & U;
+type EmitFn<T> = <K extends keyof T>(event: K, ...args: T[K] extends any[] ? T[K] : never) => void;
+type BooleanKey<T> = { [K in keyof T]: boolean extends NonNullable<T[K]> ? K : never }[keyof T];
+type BooleanDefaults<T> = { [K in BooleanKey<T>]: undefined };
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+export { Optional as a, PropTypes as c, MaybePromise as i, normalizeProps$1 as l, BooleanDefaults as n, mergeProps$1 as o, EmitFn as r, useMachine as s, Assign as t };