onejs-core 0.3.5

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/.github/workflows/jsr.yml

@@ -0,0 +1,19 @@
+# name: Publish
+# on:
+#   push:
+#     branches:
+#       - main
+
+# jobs:
+#   publish:
+#     runs-on: ubuntu-latest
+
+#     permissions:
+#       contents: read
+#       id-token: write
+
+#     steps:
+#       - uses: actions/checkout@v4
+
+#       - name: Publish package
+#         run: npx jsr publish

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "printWidth": 120,
+    "semi": false,
+    "tabWidth": 4
+}

package/3rdparty/preact/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Jason Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/3rdparty/preact/clone-element.ts

@@ -0,0 +1,45 @@
+import { assign, slice } from './util';
+import { createVNode } from './create-element';
+
+/**
+ * Clones the given VNode, optionally adding attributes/props and replacing its children.
+ * @param {import('./internal').VNode} vnode The virtual DOM element to clone
+ * @param {object} props Attributes/props to add when cloning
+ * @param {Array<import('./internal').ComponentChildren>} rest Any additional arguments will be used as replacement children.
+ * @returns {import('./internal').VNode}
+ */
+export function cloneElement(vnode, props, children) {
+	let normalizedProps = assign({}, vnode.props),
+		key,
+		ref,
+		i;
+
+	let defaultProps;
+
+	if (vnode.type && vnode.type.defaultProps) {
+		defaultProps = vnode.type.defaultProps;
+	}
+
+	for (i in props) {
+		if (i == 'key') key = props[i];
+		else if (i == 'ref') ref = props[i];
+		else if (props[i] === undefined && defaultProps !== undefined) {
+			normalizedProps[i] = defaultProps[i];
+		} else {
+			normalizedProps[i] = props[i];
+		}
+	}
+
+	if (arguments.length > 2) {
+		normalizedProps.children =
+			arguments.length > 3 ? slice.call(arguments, 2) : children;
+	}
+
+	return createVNode(
+		vnode.type,
+		normalizedProps,
+		key || vnode.key,
+		ref || vnode.ref,
+		null
+	);
+}

package/3rdparty/preact/compat/Children.ts

@@ -0,0 +1,21 @@
+import { toChildArray } from 'preact';
+
+const mapFn = (children, fn) => {
+    if (children == null) return null;
+    return toChildArray(toChildArray(children).map(fn));
+};
+
+// This API is completely unnecessary for Preact, so it's basically passthrough.
+export const Children = {
+    map: mapFn,
+    forEach: mapFn,
+    count(children) {
+        return children ? toChildArray(children).length : 0;
+    },
+    only(children) {
+        const normalized = toChildArray(children);
+        if (normalized.length !== 1) throw 'Children.only';
+        return normalized[0];
+    },
+    toArray: toChildArray
+};

package/3rdparty/preact/compat/forwardRef.ts

@@ -0,0 +1,49 @@
+import { ComponentChild, FunctionalComponent, options, Ref } from 'preact'
+import { assign } from './util'
+
+let oldDiffHook = (options as any)._diff;
+(options as any)._diff = vnode => {
+    if (vnode.type && vnode.type._forwarded && vnode.ref) {
+        vnode.props.ref = vnode.ref;
+        vnode.ref = null;
+    }
+    if (oldDiffHook) oldDiffHook(vnode);
+};
+
+export const REACT_FORWARD_SYMBOL =
+    (typeof Symbol != 'undefined' &&
+        Symbol.for &&
+        Symbol.for('react.forward_ref')) ||
+    0xf47;
+
+interface ForwardFn<P = {}, T = any> {
+    (props: P, ref: Ref<T>): ComponentChild;
+    displayName?: string;
+}
+
+/**
+ * Pass ref down to a child. This is mainly used in libraries with HOCs that
+ * wrap components. Using `forwardRef` there is an easy way to get a reference
+ * of the wrapped component instead of one of the wrapper itself.
+ * @param {import('./index').ForwardFn} fn
+ * @returns {import('./internal').FunctionComponent}
+ */
+export function forwardRef<R, P = {}>(fn: ForwardFn<P, R>): FunctionalComponent<Omit<P, 'ref'> & { ref?: Ref<R> }> {
+    function Forwarded(props) {
+        let clone = assign({}, props);
+        delete clone.ref;
+        return fn(clone, props.ref || null);
+    }
+
+    // mobx-react checks for this being present
+    Forwarded.$$typeof = REACT_FORWARD_SYMBOL;
+    // mobx-react heavily relies on implementation details.
+    // It expects an object here with a `render` property,
+    // and prototype.render will fail. Without this
+    // mobx-react throws.
+    Forwarded.render = Forwarded;
+
+    Forwarded.prototype.isReactComponent = Forwarded._forwarded = true;
+    Forwarded.displayName = 'ForwardRef(' + (fn.displayName || fn.name) + ')';
+    return Forwarded as any;
+}

package/3rdparty/preact/compat/index.ts

@@ -0,0 +1,3 @@
+export { forwardRef } from './forwardRef'
+export { memo } from './memo'
+export { Children } from './Children'

package/3rdparty/preact/compat/memo.ts

@@ -0,0 +1,34 @@
+import { FunctionComponent, createElement } from 'preact';
+import { shallowDiffers } from './util';
+
+/**
+ * Memoize a component, so that it only updates when the props actually have
+ * changed. This was previously known as `React.pure`.
+ */
+export function memo<P = {}>(
+  c: FunctionComponent<P>,
+  comparer?: (prev: P, next: P) => boolean
+): FunctionComponent<P> {
+    function shouldUpdate(nextProps) {
+        let ref = this.props.ref;
+        let updateRef = ref == nextProps.ref;
+        if (!updateRef && ref) {
+            ref.call ? ref(null) : (ref.current = null);
+        }
+
+        if (!comparer) {
+            return shallowDiffers(this.props, nextProps);
+        }
+
+        return !comparer(this.props, nextProps) || !updateRef;
+    }
+
+    function Memoed(props) {
+        this.shouldComponentUpdate = shouldUpdate;
+        return createElement(c, props);
+    }
+    Memoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';
+    Memoed.prototype.isReactComponent = true;
+    Memoed._forwarded = true;
+    return Memoed;
+}

package/3rdparty/preact/compat/util.ts

@@ -0,0 +1,38 @@
+/**
+ * Assign properties from `props` to `obj`
+ * @template O, P The obj and props types
+ * @param {O} obj The object to copy properties to
+ * @param {P} props The object to copy properties from
+ * @returns {O & P}
+ */
+export function assign(obj, props) {
+	for (let i in props) obj[i] = props[i];
+	return /** @type {O & P} */ (obj);
+}
+
+/**
+ * Check if two objects have a different shape
+ * @param {object} a
+ * @param {object} b
+ * @returns {boolean}
+ */
+export function shallowDiffers(a, b) {
+	for (let i in a) if (i !== '__source' && !(i in b)) return true;
+	for (let i in b) if (i !== '__source' && a[i] !== b[i]) return true;
+	return false;
+}
+
+export function removeNode(node) {
+	let parentNode = node.parentNode;
+	if (parentNode) parentNode.removeChild(node);
+}
+
+/**
+ * Check if two values are the same value
+ * @param {*} x
+ * @param {*} y
+ * @returns {boolean}
+ */
+export function is(x, y) {
+	return (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y);
+}

package/3rdparty/preact/component.ts

@@ -0,0 +1,235 @@
+import { assign } from './util';
+import { diff, commitRoot } from './diff/index';
+import options from './options';
+import { Fragment } from './create-element';
+
+/**
+ * Base Component class. Provides `setState()` and `forceUpdate()`, which
+ * trigger rendering
+ * @param {object} props The initial component props
+ * @param {object} context The initial context from parent components'
+ * getChildContext
+ */
+export function Component(props, context) {
+	this.props = props;
+	this.context = context;
+}
+
+/**
+ * Update component state and schedule a re-render.
+ * @this {import('./internal').Component}
+ * @param {object | ((s: object, p: object) => object)} update A hash of state
+ * properties to update with new values or a function that given the current
+ * state and props returns a new partial state
+ * @param {() => void} [callback] A function to be called once component state is
+ * updated
+ */
+Component.prototype.setState = function (update, callback) {
+	// only clone state when copying to nextState the first time.
+	let s;
+	if (this._nextState != null && this._nextState !== this.state) {
+		s = this._nextState;
+	} else {
+		s = this._nextState = assign({}, this.state);
+	}
+
+	if (typeof update == 'function') {
+		// Some libraries like `immer` mark the current state as readonly,
+		// preventing us from mutating it, so we need to clone it. See #2716
+		update = update(assign({}, s), this.props);
+	}
+
+	if (update) {
+		assign(s, update);
+	}
+
+	// Skip update if updater function returned null
+	if (update == null) return;
+
+	if (this._vnode) {
+		if (callback) this._renderCallbacks.push(callback);
+		enqueueRender(this);
+	}
+};
+
+/**
+ * Immediately perform a synchronous re-render of the component
+ * @this {import('./internal').Component}
+ * @param {() => void} [callback] A function to be called after component is
+ * re-rendered
+ */
+Component.prototype.forceUpdate = function (callback) {
+	if (this._vnode) {
+		// Set render mode so that we can differentiate where the render request
+		// is coming from. We need this because forceUpdate should never call
+		// shouldComponentUpdate
+		this._force = true;
+		if (callback) this._renderCallbacks.push(callback);
+		enqueueRender(this);
+	}
+};
+
+/**
+ * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.
+ * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).
+ * @param {object} props Props (eg: JSX attributes) received from parent
+ * element/component
+ * @param {object} state The component's current state
+ * @param {object} context Context object, as returned by the nearest
+ * ancestor's `getChildContext()`
+ * @returns {import('./index').ComponentChildren | void}
+ */
+Component.prototype.render = Fragment;
+
+/**
+ * @param {import('./internal').VNode} vnode
+ * @param {number | null} [childIndex]
+ */
+export function getDomSibling(vnode, childIndex?) {
+	if (childIndex == null) {
+		// Use childIndex==null as a signal to resume the search from the vnode's sibling
+		return vnode._parent
+			? getDomSibling(vnode._parent, vnode._parent._children.indexOf(vnode) + 1)
+			: null;
+	}
+
+	let sibling;
+	for (; childIndex < vnode._children.length; childIndex++) {
+		sibling = vnode._children[childIndex];
+
+		if (sibling !== null && typeof sibling !== "undefined" && sibling._dom !== null) { // MODDED
+			// Since updateParentDomPointers keeps _dom pointer correct,
+			// we can rely on _dom to tell us if this subtree contains a
+			// rendered DOM node, and what the first rendered DOM node is
+			return sibling._dom;
+		}
+	}
+
+	// If we get here, we have not found a DOM node in this vnode's children.
+	// We must resume from this vnode's sibling (in it's parent _children array)
+	// Only climb up and search the parent if we aren't searching through a DOM
+	// VNode (meaning we reached the DOM parent of the original vnode that began
+	// the search)
+	return typeof vnode.type == 'function' ? getDomSibling(vnode) : null;
+}
+
+/**
+ * Trigger in-place re-rendering of a component.
+ * @param {import('./internal').Component} component The component to rerender
+ */
+function renderComponent(component) {
+	let vnode = component._vnode,
+		oldDom = vnode._dom,
+		parentDom = component._parentDom;
+
+	if (parentDom) {
+		let commitQueue = [];
+		const oldVNode = assign({}, vnode);
+		oldVNode._original = vnode._original + 1;
+
+		diff(
+			parentDom,
+			vnode,
+			oldVNode,
+			component._globalContext,
+			parentDom.ownerSVGElement !== undefined,
+			vnode._hydrating != null ? [oldDom] : null,
+			commitQueue,
+			oldDom == null ? getDomSibling(vnode) : oldDom,
+			vnode._hydrating
+		);
+		commitRoot(commitQueue, vnode);
+
+		if (vnode._dom !== oldDom) { // MODDED
+			// parentDom.removeChild(oldDom)	// MODDED
+			updateParentDomPointers(vnode);
+		}
+	}
+}
+
+/**
+ * @param {import('./internal').VNode} vnode
+ */
+function updateParentDomPointers(vnode) {
+	if ((vnode = vnode._parent) !== null && vnode._component !== null) {
+		vnode._dom = vnode._component.base = null;
+		for (let i = 0; i < vnode._children.length; i++) {
+			let child = vnode._children[i];
+			if (child !== null && child._dom !== null) {
+				vnode._dom = vnode._component.base = child._dom;
+				break;
+			}
+		}
+
+		return updateParentDomPointers(vnode);
+	}
+}
+
+/**
+ * The render queue
+ * @type {Array<import('./internal').Component>}
+ */
+let rerenderQueue: any[] = [];
+
+/*
+ * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is
+ * important that contributors to Preact can consistently reason about what calls to `setState`, etc.
+ * do, and when their effects will be applied. See the links below for some further reading on designing
+ * asynchronous APIs.
+ * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)
+ * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)
+ */
+
+let prevDebounce;
+
+// MODDED
+// const defer =
+// 	typeof Promise == 'function'
+// 		? Promise.prototype.then.bind(Promise.resolve())
+// 		: setTimeout;
+
+/**
+ * Enqueue a rerender of a component
+ * @param {import('./internal').Component} c The component to rerender
+ */
+export function enqueueRender(c) {
+	if (
+		(!c._dirty &&
+			(c._dirty = true) &&
+			rerenderQueue.push(c) &&
+			!process._rerenderCount++) ||
+		prevDebounce !== options.debounceRendering
+	) {
+		prevDebounce = options.debounceRendering;
+		(prevDebounce || setTimeout)(process);
+	}
+}
+
+/**
+ * @param {import('./internal').Component} a
+ * @param {import('./internal').Component} b
+ */
+const depthSort = (a, b) => a._vnode._depth - b._vnode._depth;
+
+/** Flush the render queue by rerendering all queued components */
+function process() {
+	let c;
+	rerenderQueue.sort(depthSort);
+	// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary
+	// process() calls from getting scheduled while `queue` is still being consumed.
+	while ((c = rerenderQueue.shift())) {
+		if (c._dirty) {
+			let renderQueueLength = rerenderQueue.length;
+			renderComponent(c);
+			if (rerenderQueue.length > renderQueueLength) {
+				// When i.e. rerendering a provider additional new items can be injected, we want to
+				// keep the order from top to bottom with those new items so we can handle them in a
+				// single pass
+				rerenderQueue.sort(depthSort);
+			}
+		}
+	}
+	process._rerenderCount = 0;
+}
+
+process._rerenderCount = 0;

package/3rdparty/preact/constants.ts

@@ -0,0 +1,3 @@
+export const EMPTY_OBJ = {};
+export const EMPTY_ARR = [];
+export const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;

package/3rdparty/preact/create-context.ts

@@ -0,0 +1,71 @@
+import { enqueueRender } from './component';
+
+export let i = 0;
+
+export function createContext(defaultValue, contextId) {
+	contextId = '__cC' + i++;
+
+	const context: any = {
+		_id: contextId,
+		_defaultValue: defaultValue,
+		/** @type {import('./internal').FunctionComponent} */
+		Consumer(props, contextValue) {
+			// return props.children(
+			// 	context[contextId] ? context[contextId].props.value : defaultValue
+			// );
+			return props.children(contextValue);
+		},
+		/** @type {import('./internal').FunctionComponent} */
+		Provider(props) {
+			if (!this.getChildContext) {
+				let subs: any[] = [];
+				let ctx = {};
+				ctx[contextId] = this;
+
+				this.getChildContext = () => ctx;
+
+				this.shouldComponentUpdate = function(_props) {
+					if (this.props.value !== _props.value) {
+						// I think the forced value propagation here was only needed when `options.debounceRendering` was being bypassed:
+						// https://github.com/preactjs/preact/commit/4d339fb803bea09e9f198abf38ca1bf8ea4b7771#diff-54682ce380935a717e41b8bfc54737f6R358
+						// In those cases though, even with the value corrected, we're double-rendering all nodes.
+						// It might be better to just tell folks not to use force-sync mode.
+						// Currently, using `useContext()` in a class component will overwrite its `this.context` value.
+						// subs.some(c => {
+						// 	c.context = _props.value;
+						// 	enqueueRender(c);
+						// });
+
+						// subs.some(c => {
+						// 	c.context[contextId] = _props.value;
+						// 	enqueueRender(c);
+						// });
+						subs.some((c: any) => {
+							c._force = true;
+							enqueueRender(c);
+						});
+					}
+				};
+
+				this.sub = (c: any) => {
+					subs.push(c);
+					let old = c.componentWillUnmount;
+					c.componentWillUnmount = () => {
+						subs.splice(subs.indexOf(c), 1);
+						if (old) old.call(c);
+					};
+				};
+			}
+
+			return props.children;
+		}
+	};
+
+	// Devtools needs access to the context object when it
+	// encounters a Provider. This is necessary to support
+	// setting `displayName` on the context object instead
+	// of on the component itself. See:
+	// https://reactjs.org/docs/context.html#contextdisplayname
+
+	return (context.Provider._contextRef = context.Consumer.contextType = context);
+}

package/3rdparty/preact/create-element.ts

@@ -0,0 +1,98 @@
+import { slice } from './util';
+import options from './options';
+
+let vnodeId = 0;
+
+/**
+ * Create an virtual node (used for JSX)
+ * @param {import('./internal').VNode["type"]} type The node name or Component
+ * constructor for this virtual node
+ * @param {object | null | undefined} [props] The properties of the virtual node
+ * @param {Array<import('.').ComponentChildren>} [children] The children of the virtual node
+ * @returns {import('./internal').VNode}
+ */
+export function createElement(type, props, children) {
+	let normalizedProps: any = {},
+		key,
+		ref,
+		i;
+	for (i in props) {
+		if (i == 'key') key = props[i];
+		else if (i == 'ref') ref = props[i];
+		else normalizedProps[i] = props[i];
+	}
+
+	if (arguments.length > 2) {
+		normalizedProps.children =
+			arguments.length > 3 ? slice.call(arguments, 2) : children;
+	}
+
+	// If a Component VNode, check for and apply defaultProps
+	// Note: type may be undefined in development, must never error here.
+	if (typeof type == 'function' && type.defaultProps != null) {
+		for (i in type.defaultProps) {
+			if (normalizedProps[i] === undefined) {
+				normalizedProps[i] = type.defaultProps[i];
+			}
+		}
+	}
+
+	return createVNode(type, normalizedProps, key, ref, null);
+}
+
+/**
+ * Create a VNode (used internally by Preact)
+ * @param {import('./internal').VNode["type"]} type The node name or Component
+ * Constructor for this virtual node
+ * @param {object | string | number | null} props The properties of this virtual node.
+ * If this virtual node represents a text node, this is the text of the node (string or number).
+ * @param {string | number | null} key The key for this virtual node, used when
+ * diffing it against its children
+ * @param {import('./internal').VNode["ref"]} ref The ref property that will
+ * receive a reference to its created child
+ * @returns {import('./internal').VNode}
+ */
+export function createVNode(type, props, key, ref, original) {
+	// V8 seems to be better at detecting type shapes if the object is allocated from the same call site
+	// Do not inline into createElement and coerceToVNode!
+	const vnode = {
+		type,
+		props,
+		key,
+		ref,
+		_children: null,
+		_parent: null,
+		_depth: 0,
+		_dom: null,
+		// _nextDom must be initialized to undefined b/c it will eventually
+		// be set to dom.nextSibling which can return `null` and it is important
+		// to be able to distinguish between an uninitialized _nextDom and
+		// a _nextDom that has been set to `null`
+		_nextDom: undefined,
+		_component: null,
+		_hydrating: null,
+		constructor: undefined,
+		_original: original == null ? ++vnodeId : original
+	};
+
+	// Only invoke the vnode hook if this was *not* a direct copy:
+	if (original == null && options.vnode != null) options.vnode(vnode);
+
+	return vnode;
+}
+
+export function createRef() {
+	return { current: null };
+}
+
+export function Fragment(props) {
+	return props.children;
+}
+
+/**
+ * Check if a the argument is a valid Preact VNode.
+ * @param {*} vnode
+ * @returns {vnode is import('./internal').VNode}
+ */
+export const isValidElement = vnode =>
+	vnode != null && vnode.constructor === undefined;