@sprawlify/solid 0.0.14 → 0.0.15

package/dist/run-if-fn-eYlaegHy.js

@@ -0,0 +1,421 @@
+import { Key } from "@solid-primitives/keyed";
+import { INIT_STATE, MachineStatus, createScope, mergeProps } from "@sprawlify/primitives/core";
+import { compact, ensure, isEqual, isFunction, isNumber, isObject, isString, toArray, warn } from "@sprawlify/primitives/utils";
+import { createEffect, createMemo, createSignal, mergeProps as mergeProps$1, onCleanup, onMount, untrack } from "solid-js";
+import { createNormalizer } from "@sprawlify/primitives/types";
+
+//#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$1) {
+			props().onChange?.(nextValue, prevValue$1);
+		},
+		hash(value$1) {
+			return props().hash?.(value$1) ?? String(value$1);
+		}
+	};
+}
+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$1(eventRef.current, {
+		current() {
+			return eventRef.current;
+		},
+		previous() {
+			return previousEventRef.current;
+		}
+	});
+	const getState = () => mergeProps$1(state, {
+		matches(...values) {
+			const current = state.get();
+			return values.includes(current);
+		},
+		hasTag(tag) {
+			const current = state.get();
+			return !!machine.states[current]?.tags?.includes(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(`[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 = (key) => {
+		ensure(machine.computed, () => `[sprawlify-js] 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: machine.initialState({ prop }),
+		onChange(nextState, prevState) {
+			if (prevState) {
+				effects.current.get(prevState)?.();
+				effects.current.delete(prevState);
+			}
+			if (prevState) action(machine.states[prevState]?.exit);
+			action(transitionRef.current?.actions);
+			const cleanup = effect(machine.states[nextState]?.effects);
+			if (cleanup) effects.current.set(nextState, cleanup);
+			if (prevState === INIT_STATE) {
+				action(machine.entry);
+				const cleanup$1 = effect(machine.effects);
+				if (cleanup$1) effects.current.set(INIT_STATE, cleanup$1);
+			}
+			action(machine.states[nextState]?.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 transition = choose(machine.states[currentState].on?.[event.type] ?? machine.on?.[event.type]);
+			if (!transition) return;
+			transitionRef.current = 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();
+		},
+		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/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$1 = 0; i$1 < sources.length; i$1++) {
+								let s = sources[i$1];
+								if (typeof s === "function") s = s();
+								e = mergeProps(e, { [key]: (s || {})[key] });
+							}
+							return e[key];
+						}
+						for (let i$1 = sources.length - 1; i$1 >= 0; i$1--) {
+							let v, s = sources[i$1];
+							if (typeof s === "function") s = s();
+							v = (s || {})[key];
+							if (v !== void 0) return v;
+						}
+					}
+				});
+			}
+		}
+	}
+	return target;
+}
+
+//#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];
+	var hName = name.replace(uppercasePattern, toHyphenLower);
+	return cache[name] = msPattern.test(hName) ? "-" + hName : hName;
+}
+
+//#endregion
+//#region src/utils/run-if-fn.ts
+const isFunction$1 = (value) => typeof value === "function";
+const runIfFn = (valueOrFn, ...args) => isFunction$1(valueOrFn) ? valueOrFn(...args) : valueOrFn;
+
+//#endregion
+export { useMachine as a, mergeProps$2 as i, Key as n, normalizeProps as r, runIfFn as t };

package/dist/types-bQRbEioA.d.ts

@@ -0,0 +1,9 @@
+import { Accessor } from "solid-js";
+
+//#region src/types.d.ts
+type Assign<T, U> = Omit<T, keyof U> & U;
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type MaybeAccessor<T> = Accessor<T> | T;
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+export { Optional as i, MaybeAccessor as n, MaybePromise as r, Assign as t };

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
-import { t as createContext } from "../index-C_ThrXdH.js";
+import { t as createContext } from "../index-B0YoIRC4.js";
 export { createContext };

package/dist/utils/index.js

@@ -1,3 +1,4 @@
-import { t as createContext } from "../utils-GEMuT7an.js";
+import { t as createContext } from "../create-context-PS2j4mEo.js";
+import "../utils-DYer-9SY.js";
 
 export { createContext };

package/dist/utils/index.jsx

@@ -1,3 +1,4 @@
-import { t as createContext } from "../utils-DSKoW7eB.jsx";
+import { t as createContext } from "../create-context-h3cXiEld.jsx";
+import "../utils-DrvO4Hk3.jsx";
 
 export { createContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sprawlify/solid",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "type": "module",
   "description": "Solid wrapper for primitives.",
   "author": "sprawlify <npm@sprawlify.com>",
@@ -12,6 +12,66 @@
       "types": "./dist/index.d.ts",
       "solid": "./dist/index.jsx",
       "default": "./dist/index.js"
+    },
+    "./accordion": {
+      "types": "./dist/components/accordion/index.d.ts",
+      "solid": "./dist/components/accordion/index.jsx",
+      "default": "./dist/components/accordion/index.js"
+    },
+    "./angle-slider": {
+      "types": "./dist/components/angle-slider/index.d.ts",
+      "solid": "./dist/components/angle-slider/index.jsx",
+      "default": "./dist/components/angle-slider/index.js"
+    },
+    "./avatar": {
+      "types": "./dist/components/avatar/index.d.ts",
+      "solid": "./dist/components/avatar/index.jsx",
+      "default": "./dist/components/avatar/index.js"
+    },
+    "./bottom-sheet": {
+      "types": "./dist/components/bottom-sheet/index.d.ts",
+      "solid": "./dist/components/bottom-sheet/index.jsx",
+      "default": "./dist/components/bottom-sheet/index.js"
+    },
+    "./carousel": {
+      "types": "./dist/components/carousel/index.d.ts",
+      "solid": "./dist/components/carousel/index.jsx",
+      "default": "./dist/components/carousel/index.js"
+    },
+    "./checkbox": {
+      "types": "./dist/components/checkbox/index.d.ts",
+      "solid": "./dist/components/checkbox/index.jsx",
+      "default": "./dist/components/checkbox/index.js"
+    },
+    "./client-only": {
+      "types": "./dist/components/client-only/index.d.ts",
+      "solid": "./dist/components/client-only/index.jsx",
+      "default": "./dist/components/client-only/index.js"
+    },
+    "./clipboard": {
+      "types": "./dist/components/clipboard/index.d.ts",
+      "solid": "./dist/components/clipboard/index.jsx",
+      "default": "./dist/components/clipboard/index.js"
+    },
+    "./collapsible": {
+      "types": "./dist/components/collapsible/index.d.ts",
+      "solid": "./dist/components/collapsible/index.jsx",
+      "default": "./dist/components/collapsible/index.js"
+    },
+    "./field": {
+      "types": "./dist/components/field/index.d.ts",
+      "solid": "./dist/components/field/index.jsx",
+      "default": "./dist/components/field/index.js"
+    },
+    "./fieldset": {
+      "types": "./dist/components/fieldset/index.d.ts",
+      "solid": "./dist/components/fieldset/index.jsx",
+      "default": "./dist/components/fieldset/index.js"
+    },
+    "./presence": {
+      "types": "./dist/components/presence/index.d.ts",
+      "solid": "./dist/components/presence/index.jsx",
+      "default": "./dist/components/presence/index.js"
     }
   },
   "files": [
@@ -22,7 +82,7 @@
   },
   "dependencies": {
     "@solid-primitives/keyed": "^1.5.2",
-    "@sprawlify/primitives": "0.0.14"
+    "@sprawlify/primitives": "0.0.15"
   },
   "peerDependencies": {
     "solid-js": ">=1.1.3"