@wirekyt/solid 0.0.1 → 0.0.2

package/dist/core-7QKBNp9p.jsx

@@ -0,0 +1,485 @@
+import { callAll, compact, ensure, hasProp, isEqual, isFunction, isNumber, isObject, isString, toArray, warn } from "@wirekyt/dom/utils";
+import { createContext, createEffect, createMemo, createSignal, mergeProps, onCleanup, onMount, splitProps, untrack, useContext } from "solid-js";
+import { Key } from "@solid-primitives/keyed";
+import { INIT_STATE, MachineStatus, createScope, findTransition, getExitEnterStates, hasTag, matchesState, mergeProps as mergeProps$1, resolveStateValue } from "@wirekyt/dom";
+import { createNormalizer } from "@wirekyt/dom/types";
+//#region src/utils/create-context.ts
+function getErrorMessage(hook, provider) {
+	return `${hook} returned \`undefined\`. Seems you forgot to wrap component within ${provider}`;
+}
+function createContext$1(options = {}) {
+	const { strict = true, hookName = "useContext", providerName = "Provider", errorMessage, defaultValue } = options;
+	const Context = createContext(defaultValue);
+	function useContext$1() {
+		const context = useContext(Context);
+		if (!context && strict) {
+			const error = new Error(errorMessage ?? getErrorMessage(hookName, providerName));
+			error.name = "ContextError";
+			if (hasProp(Error, "captureStackTrace") && isFunction(Error.captureStackTrace)) Error.captureStackTrace(error, useContext$1);
+			throw error;
+		}
+		return context;
+	}
+	return [
+		Context.Provider,
+		useContext$1,
+		Context
+	];
+}
+//#endregion
+//#region src/utils/compose-refs.ts
+const isRefFn = (ref) => typeof ref === "function";
+const setRefs = (refs, node) => {
+	for (const ref of refs) if (isRefFn(ref)) ref(node);
+};
+function composeRefs(...refs) {
+	let node = null;
+	createEffect(() => {
+		setRefs(refs, node);
+	});
+	return (el) => {
+		node = el;
+		setRefs(refs, el);
+	};
+}
+//#endregion
+//#region src/utils/create-split-props.ts
+const createSplitProps = () => (props, keys) => splitProps(props, keys);
+//#endregion
+//#region src/utils/render-strategy.ts
+const [RenderStrategyProvider, useRenderStrategyContext] = createContext$1({
+	hookName: "useRenderStrategyContext",
+	providerName: "<RenderStrategyProvider />"
+});
+const splitRenderStrategyProps = (props) => createSplitProps()(props, ["lazyMount", "unmountOnExit"]);
+//#endregion
+//#region src/core/merge-props.ts
+function mergeProps$2(...sources) {
+	const target = {};
+	for (let i = 0; i < sources.length; i++) {
+		let source = sources[i];
+		if (typeof source === "function") source = source();
+		if (source) {
+			const descriptors = Object.getOwnPropertyDescriptors(source);
+			for (const key in descriptors) {
+				if (key in target) continue;
+				Object.defineProperty(target, key, {
+					enumerable: true,
+					get() {
+						let e = {};
+						if (key === "style" || key === "class" || key === "className" || key.startsWith("on")) {
+							for (let i = 0; i < sources.length; i++) {
+								let s = sources[i];
+								if (typeof s === "function") s = s();
+								e = mergeProps$1(e, { [key]: (s || {})[key] });
+							}
+							return e[key];
+						}
+						for (let i = sources.length - 1; i >= 0; i--) {
+							let v, s = sources[i];
+							if (typeof s === "function") s = s();
+							v = (s || {})[key];
+							if (v !== void 0) return v;
+						}
+					}
+				});
+			}
+		}
+	}
+	return target;
+}
+//#endregion
+//#region src/core/bindable.ts
+function createBindable(props) {
+	const initial = props().value ?? props().defaultValue;
+	const eq = props().isEqual ?? Object.is;
+	const [value, setValue] = createSignal(initial);
+	const controlled = createMemo(() => props().value != void 0);
+	const valueRef = { current: value() };
+	const prevValue = { current: void 0 };
+	createEffect(() => {
+		const v = controlled() ? props().value : value();
+		prevValue.current = v;
+		valueRef.current = v;
+	});
+	const set = (v) => {
+		const prev = prevValue.current;
+		const next = isFunction(v) ? v(valueRef.current) : v;
+		if (props().debug) console.log(`[bindable > ${props().debug}] setValue`, {
+			next,
+			prev
+		});
+		if (!controlled()) setValue(next);
+		if (!eq(next, prev)) props().onChange?.(next, prev);
+	};
+	function get() {
+		const v = controlled() ? props().value : value;
+		return isFunction(v) ? v() : v;
+	}
+	return {
+		initial,
+		ref: valueRef,
+		get,
+		set,
+		invoke(nextValue, prevValue) {
+			props().onChange?.(nextValue, prevValue);
+		},
+		hash(value) {
+			return props().hash?.(value) ?? String(value);
+		}
+	};
+}
+createBindable.cleanup = (fn) => {
+	onCleanup(() => fn());
+};
+createBindable.ref = (defaultValue) => {
+	let value = defaultValue;
+	return {
+		get: () => value,
+		set: (next) => {
+			value = next;
+		}
+	};
+};
+//#endregion
+//#region src/core/refs.ts
+function createRefs(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
+function access$1(v) {
+	if (isFunction(v)) return v();
+	return v;
+}
+const createTrack = (deps, effect) => {
+	let prevDeps = [];
+	let isFirstRun = true;
+	createEffect(() => {
+		if (isFirstRun) {
+			prevDeps = deps.map((d) => access$1(d));
+			isFirstRun = false;
+			return;
+		}
+		let changed = false;
+		for (let i = 0; i < deps.length; i++) if (!isEqual(prevDeps[i], access$1(deps[i]))) {
+			changed = true;
+			break;
+		}
+		if (changed) {
+			prevDeps = deps.map((d) => access$1(d));
+			effect();
+		}
+	});
+};
+//#endregion
+//#region src/core/machine.ts
+function useMachine(machine, userProps = {}) {
+	const scope = createMemo(() => {
+		const { id, ids, getRootNode } = access(userProps);
+		return createScope({
+			id,
+			ids,
+			getRootNode
+		});
+	});
+	const debug = (...args) => {
+		if (machine.debug) console.log(...args);
+	};
+	const prop = createProp(createMemo(() => machine.props?.({
+		props: compact(access(userProps)),
+		scope: scope()
+	}) ?? access(userProps)));
+	const context = machine.context?.({
+		prop,
+		bindable: createBindable,
+		get scope() {
+			return scope();
+		},
+		flush,
+		getContext() {
+			return ctx;
+		},
+		getComputed() {
+			return computed;
+		},
+		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);
+		}
+	};
+	const effects = { current: /* @__PURE__ */ new Map() };
+	const transitionRef = { current: null };
+	const previousEventRef = { current: null };
+	const eventRef = { current: { type: "" } };
+	const getEvent = () => mergeProps(eventRef.current, {
+		current() {
+			return eventRef.current;
+		},
+		previous() {
+			return previousEventRef.current;
+		}
+	});
+	const getState = () => mergeProps(state, {
+		matches(...values) {
+			const current = state.get();
+			return values.some((value) => matchesState(current, value));
+		},
+		hasTag(tag) {
+			return hasTag(machine, state.get(), tag);
+		}
+	});
+	const refs = createRefs(machine.refs?.({
+		prop,
+		context: ctx
+	}) ?? {});
+	const getParams = () => ({
+		state: getState(),
+		context: ctx,
+		event: getEvent(),
+		prop,
+		send,
+		action,
+		guard,
+		track: createTrack,
+		refs,
+		computed,
+		flush,
+		get scope() {
+			return scope();
+		},
+		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 = (key) => {
+		ensure(machine.computed, () => `[wirekyt] No computed object found on machine`);
+		const fn = machine.computed[key];
+		return fn({
+			context: ctx,
+			event: eventRef.current,
+			prop,
+			refs,
+			scope: scope(),
+			computed
+		});
+	};
+	const state = createBindable(() => ({
+		defaultValue: resolveStateValue(machine, machine.initialState({ prop })),
+		onChange(nextState, prevState) {
+			const { exiting, entering } = getExitEnterStates(machine, prevState, nextState, transitionRef.current?.reenter);
+			exiting.forEach((item) => {
+				effects.current.get(item.path)?.();
+				effects.current.delete(item.path);
+			});
+			exiting.forEach((item) => {
+				action(item.state?.exit);
+			});
+			action(transitionRef.current?.actions);
+			entering.forEach((item) => {
+				const cleanup = effect(item.state?.effects);
+				if (cleanup) {
+					const existing = effects.current.get(item.path);
+					effects.current.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.current.get(INIT_STATE);
+					effects.current.set(INIT_STATE, existing ? callAll(existing, cleanup) : cleanup);
+				}
+			}
+			entering.forEach((item) => {
+				action(item.state?.entry);
+			});
+		}
+	}));
+	let status = MachineStatus.NotStarted;
+	onMount(() => {
+		const started = status === MachineStatus.Started;
+		status = MachineStatus.Started;
+		debug(started ? "rehydrating..." : "initializing...");
+		state.invoke(state.initial, INIT_STATE);
+	});
+	onCleanup(() => {
+		debug("unmounting...");
+		status = MachineStatus.Stopped;
+		effects.current.forEach((fn) => fn?.());
+		effects.current = /* @__PURE__ */ new Map();
+		transitionRef.current = null;
+		action(machine.exit);
+	});
+	const send = (event) => {
+		queueMicrotask(() => {
+			if (status !== MachineStatus.Started) return;
+			previousEventRef.current = eventRef.current;
+			eventRef.current = event;
+			let currentState = untrack(() => state.get());
+			const { transitions, source } = findTransition(machine, currentState, event.type);
+			const transition = choose(transitions);
+			if (!transition) return;
+			transitionRef.current = 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();
+		},
+		refs,
+		computed,
+		event: getEvent(),
+		getStatus: () => status
+	};
+}
+function flush(fn) {
+	fn();
+}
+function access(value) {
+	return isFunction(value) ? value() : value;
+}
+function createProp(value) {
+	return function get(key) {
+		return value()[key];
+	};
+}
+//#endregion
+//#region src/core/normalize-props.ts
+const eventMap = {
+	onFocus: "onFocusIn",
+	onBlur: "onFocusOut",
+	onDoubleClick: "onDblClick",
+	onChange: "onInput",
+	defaultChecked: "checked",
+	defaultValue: "value",
+	htmlFor: "for",
+	className: "class"
+};
+const format = (v) => v.startsWith("--") ? v : hyphenateStyleName(v);
+function toSolidProp(prop) {
+	return prop in eventMap ? eventMap[prop] : prop;
+}
+const normalizeProps = createNormalizer((props) => {
+	const normalized = {};
+	for (const key in props) {
+		const value = props[key];
+		if (key === "readOnly" && value === false) continue;
+		if (key === "style" && isObject(value)) {
+			normalized["style"] = cssify(value);
+			continue;
+		}
+		if (key === "children") {
+			if (isString(value)) normalized["textContent"] = value;
+			continue;
+		}
+		normalized[toSolidProp(key)] = value;
+	}
+	return normalized;
+});
+function cssify(style) {
+	let css = {};
+	for (const property in style) {
+		const value = style[property];
+		if (!isString(value) && !isNumber(value)) continue;
+		css[format(property)] = value;
+	}
+	return css;
+}
+const uppercasePattern = /[A-Z]/g;
+const msPattern = /^ms-/;
+function toHyphenLower(match) {
+	return "-" + match.toLowerCase();
+}
+const cache = {};
+function hyphenateStyleName(name) {
+	if (cache.hasOwnProperty(name)) return cache[name];
+	const hName = name.replace(uppercasePattern, toHyphenLower);
+	return cache[name] = msPattern.test(hName) ? "-" + hName : hName;
+}
+//#endregion
+//#region src/core/use-sync-external-store.ts
+function useSyncExternalStore(subscribe, getSnapshot, _getServerSnapshot) {
+	const [snapshot, setSnapshot] = createSignal(getSnapshot());
+	onMount(() => {
+		setSnapshot(() => getSnapshot());
+		onCleanup(subscribe(() => {
+			setSnapshot(() => getSnapshot());
+		}));
+	});
+	return snapshot;
+}
+//#endregion
+export { mergeProps$2 as a, useRenderStrategyContext as c, createContext$1 as d, useMachine as i, createSplitProps as l, useSyncExternalStore as n, RenderStrategyProvider as o, normalizeProps as r, splitRenderStrategyProps as s, Key as t, composeRefs as u };

package/dist/date-input.d.ts

@@ -0,0 +1,68 @@
+import { a as Optional, r as MaybeAccessor, s as PropTypes } from "./index-ClU-Lb8Z.js";
+import { r as PolymorphicProps, t as HTMLProps } from "./factory-wuwfJqbU.js";
+import { Accessor, JSX } from "solid-js";
+import * as dateInput from "@wirekyt/dom/machines/date-input";
+import { DateSegment, DateValue as DateInputDateValue, FocusChangeDetails as DateInputFocusChangeDetails, HiddenInputProps, SegmentGroupProps, SegmentProps, SelectionMode as DateInputSelectionMode, ValueChangeDetails as DateInputValueChangeDetails, anatomy as dateInputAnatomy } from "@wirekyt/dom/machines/date-input";
+//#region src/components/date-input/use-date-input.d.ts
+interface UseDateInputProps extends Optional<Omit<dateInput.Props, "dir" | "getRootNode">, "id"> {}
+interface UseDateInputReturn extends Accessor<dateInput.Api<PropTypes>> {}
+declare const useDateInput: (props?: MaybeAccessor<UseDateInputProps>) => UseDateInputReturn;
+//#endregion
+//#region src/components/date-input/use-context.d.ts
+interface UseDateInputContext extends UseDateInputReturn {}
+declare const DateInputProvider: import("solid-js").ContextProviderComponent<UseDateInputContext>, useDateInputContext: () => UseDateInputContext;
+//#endregion
+//#region src/components/date-input/context.d.ts
+interface DateInputContextProps {
+  children: (context: UseDateInputContext) => JSX.Element;
+}
+declare const DateInputContext: (props: DateInputContextProps) => JSX.Element;
+//#endregion
+//#region src/components/date-input/label.d.ts
+interface DateInputLabelBaseProps extends PolymorphicProps<"label"> {}
+interface DateInputLabelProps extends HTMLProps<"label">, DateInputLabelBaseProps {}
+declare const DateInputLabel: (props: DateInputLabelProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/root.d.ts
+interface DateInputRootBaseProps extends UseDateInputProps, PolymorphicProps<"div"> {}
+interface DateInputRootProps extends HTMLProps<"div">, DateInputRootBaseProps {}
+declare const DateInputRoot: (props: DateInputRootProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/root-provider.d.ts
+interface RootProviderProps {
+  value: UseDateInputReturn;
+}
+interface DateInputRootProviderBaseProps extends RootProviderProps, PolymorphicProps<"div"> {}
+interface DateInputRootProviderProps extends HTMLProps<"div">, DateInputRootProviderBaseProps {}
+declare const DateInputRootProvider: (props: DateInputRootProviderProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/segment.d.ts
+interface DateInputSegmentBaseProps extends PolymorphicProps<"span">, Pick<SegmentProps, "segment"> {}
+interface DateInputSegmentProps extends HTMLProps<"span">, DateInputSegmentBaseProps {}
+declare const DateInputSegment: (props: DateInputSegmentProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/segment-group.d.ts
+interface DateInputSegmentGroupBaseProps extends PolymorphicProps<"div">, SegmentGroupProps {}
+interface DateInputSegmentGroupProps extends HTMLProps<"div">, DateInputSegmentGroupBaseProps {}
+declare const DateInputSegmentGroup: (props: DateInputSegmentGroupProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/hidden-input.d.ts
+interface DateInputHiddenInputBaseProps extends PolymorphicProps<"input">, HiddenInputProps {}
+interface DateInputHiddenInputProps extends HTMLProps<"input">, DateInputHiddenInputBaseProps {}
+declare const DateInputHiddenInput: (props: DateInputHiddenInputProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/control.d.ts
+interface DateInputControlBaseProps extends PolymorphicProps<"div"> {}
+interface DateInputControlProps extends HTMLProps<"div">, DateInputControlBaseProps {}
+declare const DateInputControl: (props: DateInputControlProps) => import("solid-js").JSX.Element;
+//#endregion
+//#region src/components/date-input/segment-context.d.ts
+interface DateInputSegmentContextProps {
+  children: (segment: DateSegment) => JSX.Element;
+}
+declare const DateInputSegmentContext: (props: DateInputSegmentContextProps) => JSX.Element;
+declare namespace date_input_d_exports {
+  export { DateInputContext as Context, DateInputContextProps as ContextProps, DateInputControl as Control, DateInputControlBaseProps as ControlBaseProps, DateInputControlProps as ControlProps, DateInputHiddenInput as HiddenInput, DateInputHiddenInputBaseProps as HiddenInputBaseProps, DateInputHiddenInputProps as HiddenInputProps, DateInputLabel as Label, DateInputLabelBaseProps as LabelBaseProps, DateInputLabelProps as LabelProps, DateInputRoot as Root, DateInputRootBaseProps as RootBaseProps, DateInputRootProps as RootProps, DateInputRootProvider as RootProvider, DateInputRootProviderBaseProps as RootProviderBaseProps, DateInputRootProviderProps as RootProviderProps, DateInputSegment as Segment, DateInputSegmentBaseProps as SegmentBaseProps, DateInputSegmentContext as SegmentContext, DateInputSegmentContextProps as SegmentContextProps, DateInputSegmentGroup as SegmentGroup, DateInputSegmentGroupBaseProps as SegmentGroupBaseProps, DateInputSegmentGroupProps as SegmentGroupProps, DateInputSegmentProps as SegmentProps };
+}
+//#endregion
+export { date_input_d_exports as DateInput, DateInputContext, type DateInputContextProps, DateInputControl, type DateInputControlBaseProps, type DateInputControlProps, type DateInputDateValue, type DateInputFocusChangeDetails, DateInputHiddenInput, type DateInputHiddenInputBaseProps, type DateInputHiddenInputProps, DateInputLabel, type DateInputLabelBaseProps, type DateInputLabelProps, DateInputRoot, type DateInputRootBaseProps, type DateInputRootProps, DateInputRootProvider, type DateInputRootProviderBaseProps, type DateInputRootProviderProps, DateInputSegment, type DateInputSegmentBaseProps, DateInputSegmentContext, type DateInputSegmentContextProps, DateInputSegmentGroup, type DateInputSegmentGroupBaseProps, type DateInputSegmentGroupProps, type DateInputSegmentProps, type DateInputSelectionMode, type DateInputValueChangeDetails, type UseDateInputContext, type UseDateInputProps, type UseDateInputReturn, dateInputAnatomy, useDateInput, useDateInputContext };