onejs-core 0.3.5 → 0.3.6

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

@@ -1,21 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

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

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

@@ -1,34 +0,0 @@
-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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,235 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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;

package/3rdparty/preact/diff/catch-error.ts

@@ -1,40 +0,0 @@
-/**
- * Find the closest error boundary to a thrown error and call it
- * @param {object} error The thrown value
- * @param {import('../internal').VNode} vnode The vnode that threw
- * the error that was caught (except for unmounting when this parameter
- * is the highest parent that was being unmounted)
- * @param {import('../internal').VNode} [oldVNode]
- * @param {import('../internal').ErrorInfo} [errorInfo]
- */
-export function _catchError(error, vnode, oldVNode, errorInfo) {
-	/** @type {import('../internal').Component} */
-	let component, ctor, handled;
-
-	for (; (vnode = vnode._parent); ) {
-		if ((component = vnode._component) && !component._processingException) {
-			try {
-				ctor = component.constructor;
-
-				if (ctor && ctor.getDerivedStateFromError != null) {
-					component.setState(ctor.getDerivedStateFromError(error));
-					handled = component._dirty;
-				}
-
-				if (component.componentDidCatch != null) {
-					component.componentDidCatch(error, errorInfo || {});
-					handled = component._dirty;
-				}
-
-				// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.
-				if (handled) {
-					return (component._pendingError = component);
-				}
-			} catch (e) {
-				error = e;
-			}
-		}
-	}
-
-	throw error;
-}