pixuireactcomponents 1.2.0 → 1.2.2

package/lib/preact/src/options.js

@@ -1,16 +0,0 @@
-import { _catchError } from './diff/catch-error';
-
-/**
- * The `option` object can potentially contain callback functions
- * that are called during various stages of our renderer. This is the
- * foundation on which all our addons like `preact/debug`, `preact/compat`,
- * and `preact/hooks` are based on. See the `Options` type in `internal.d.ts`
- * for a full list of available option hooks (most editors/IDEs allow you to
- * ctrl+click or cmd+click on mac the type definition below).
- * @type {import('./internal').Options}
- */
-const options = {
-	_catchError
-};
-
-export default options;

package/lib/preact/src/render.js

@@ -1,98 +0,0 @@
-import { EMPTY_OBJ, EMPTY_ARR } from './constants';
-import { commitRoot, diff } from './diff/index';
-import { createElement, Fragment } from './create-element';
-import options from './options';
-
-const IS_HYDRATE = EMPTY_OBJ;
-
-let stringify = function (obj) {
-	let seen = [];
-
-	return JSON.stringify(
-		obj,
-		function (key, val) {
-			if (val != null && typeof val == 'object') {
-				if (seen.indexOf(val) >= 0) {
-					return;
-				}
-				seen.push(val);
-			}
-			return val;
-		},
-		2
-	);
-};
-/**
- * Render a Preact virtual node into a DOM element
- * @param {import('./index').ComponentChild} vnode The virtual node to render
- * @param {import('./internal').PreactElement} parentDom The DOM element to
- * render into
- * @param {Element | Text} [replaceNode] Optional: Attempt to re-use an
- * existing DOM tree rooted at `replaceNode`
- */
-export function render(vnode, parentDom, replaceNode) {
-	if (options._root) options._root(vnode, parentDom);
-
-	// We abuse the `replaceNode` parameter in `hydrate()` to signal if we
-	// are in hydration mode or not by passing `IS_HYDRATE` instead of a
-	// DOM element.
-	let isHydrating = replaceNode === IS_HYDRATE;
-
-	// To be able to support calling `render()` multiple times on the same
-	// DOM node, we need to obtain a reference to the previous tree. We do
-	// this by assigning a new `_children` property to DOM nodes which points
-	// to the last rendered tree. By default this property is not present, which
-	// means that we are mounting a new tree for the first time.
-	let oldVNode = isHydrating ? null : (replaceNode && replaceNode._children) || parentDom._children;
-	// console.log('in vnode:', vnode);
-	vnode = createElement(Fragment, null, [vnode]);
-	// console.log('out vnode:', vnode);
-
-	window.opList = [];
-	window.clearOP = () => {
-		window.opList = [];
-	};
-	window.addOP = (op) => {
-		if(window.debugVDomDiff)
-			window.opList.push(op);
-	};
-	window.dumpOP = (from) => {
-		if(window.debugVDomDiff)
-			console.log(`** opList(${from}) **\n` + window.opList.join('\n'), '\n');
-	};
-
-	// List of effects that need to be called after diffing.
-	let commitQueue = [];
-	diff(
-		parentDom,
-		// Determine the new vnode tree and store it on the DOM element on
-		// our custom `_children` property.
-		((isHydrating ? parentDom : replaceNode || parentDom)._children = vnode),
-		oldVNode || EMPTY_OBJ,
-		EMPTY_OBJ,
-		parentDom.ownerSVGElement !== undefined,
-		replaceNode && !isHydrating
-			? [replaceNode]
-			: oldVNode
-			? null
-			: EMPTY_ARR.slice.call(parentDom.childNodes),
-		commitQueue,
-		replaceNode || EMPTY_OBJ,
-		isHydrating
-	);
-
-	window.dumpOP('render');
-
-	// Flush all queued effects
-	commitRoot(commitQueue, vnode);
-}
-
-/**
- * Update an existing DOM element with data from a Preact virtual node
- * @param {import('./index').ComponentChild} vnode The virtual node to render
- * @param {import('./internal').PreactElement} parentDom The DOM element to
- * update
- */
-export function hydrate(vnode, parentDom) {
-	render(vnode, parentDom, IS_HYDRATE);
-}

package/lib/preact/src/util.js

@@ -1,25 +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);
-}
-
-/**
- * Remove a child node from its parent if attached. This is a workaround for
- * IE11 which doesn't support `Element.prototype.remove()`. Using this function
- * is smaller than including a dedicated polyfill.
- * @param {Node} node The node to remove
- */
-export function removeNode(node) {
-	let parentNode = node.parentNode;
-	addOP(
-		`removeChild ${node.tagName || node.nodeName} of ${parentNode.tagName || parentNode.nodeName}`
-	);
-	if (parentNode) parentNode.removeChild(node);
-}

package/lib/preact-router/.travis.yml

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - stable

package/lib/preact-router/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 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/lib/preact-router/README.md

@@ -1,254 +0,0 @@
-# preact-router
-
-[![NPM](https://img.shields.io/npm/v/preact-router.svg)](https://www.npmjs.com/package/preact-router)
-[![travis-ci](https://travis-ci.org/developit/preact-router.svg)](https://travis-ci.org/developit/preact-router)
-
-Connect your [Preact] components up to that address bar.
-
-`preact-router` provides a `<Router />` component that conditionally renders its children when the URL matches their `path`. It also automatically wires up `<a />` elements to the router.
-
-> 💁 **Note:** This is not a preact-compatible version of React Router. `preact-router` is a simple URL wiring and does no orchestration for you.
->
-> If you're looking for more complex solutions like nested routes and view composition, [react-router](https://github.com/ReactTraining/react-router) works great with preact as long as you alias in [preact-compat](https://github.com/developit/preact-compat).  React Router 4 even [works directly with Preact](https://codepen.io/developit/pen/BWxepY?editors=0010), no compatibility layer needed!
-
-#### [See a Real-world Example :arrow_right:](https://jsfiddle.net/developit/qc73v9va/)
-
-
----
-
-
-### Usage Example
-
-```js
-import Router from 'preact-router';
-import { h, render } from 'preact';
-/** @jsx h */
-
-const Main = () => (
-	<Router>
-		<Home path="/" />
-		<About path="/about" />
-		// Advanced is an optional query
-		<Search path="/search/:query/:advanced?" />
-	</Router>
-);
-
-render(<Main />, document.body);
-```
-
-If there is an error rendering the destination route, a 404 will be displayed.
-
-
-### Handling URLS
-
-:information_desk_person: Pages are just regular components that get mounted when you navigate to a certain URL.
-Any URL parameters get passed to the component as `props`.
-
-Defining what component(s) to load for a given URL is easy and declarative.
-You can even mix-and-match URL parameters and normal `props`.
-You can also make params optional by adding a `?` to it.
-
-```js
-<Router>
-  <A path="/" />
-  <B path="/b" id="42" />
-  <C path="/c/:id" />
-  <C path="/d/:optional?/:params?" />
-  <D default />
-</Router>
-```
-
-
-### Lazy Loading
-
-Lazy loading (code splitting) with `preact-router` can be implemented easily using the [AsyncRoute](https://www.npmjs.com/package/preact-async-route) module:
-
-```js
-import AsyncRoute from 'preact-async-route';
-<Router>
-  <Home path="/" />
-  <AsyncRoute
-    path="/friends"
-    getComponent={ () => import('./friends').then(module => module.default) }
-  />
-  <AsyncRoute
-    path="/friends/:id"
-    getComponent={ () => import('./friend').then(module => module.default) }
-    loading={ () => <div>loading...</div> }
-  />
-</Router>
-```
-
-
-### Active Matching & Links
-
-`preact-router` includes an add-on module called `match` that lets you wire your components up to Router changes.
-
-Here's a demo of `<Match>`, which invokes the function you pass it (as its only child) in response to any routing:
-
-```js
-import Router from 'preact-router';
-import Match from 'preact-router/match';
-
-render(
-  <div>
-    <Match path="/">
-      { ({ matches, path, url }) => (
-        <pre>{url}</pre>
-      ) }
-    </Match>
-    <Router>
-      <div default>demo fallback route</div>
-    </Router>
-  </div>
-)
-
-// another example: render only if at a given URL:
-
-render(
-  <div>
-    <Match path="/">
-      { ({ matches }) => matches && (
-        <h1>You are Home!</h1>
-      ) }
-    </Match>
-    <Router />
-  </div>
-)
-```
-
-`<Link>` is just a normal link, but it automatically adds and removes an "active" classname to itself based on whether it matches the current URL.
-
-```js
-import { Router } from 'preact-router';
-import { Link } from 'preact-router/match';
-
-render(
-  <div>
-    <nav>
-      <Link activeClassName="active" href="/">Home</Link>
-      <Link activeClassName="active" href="/foo">Foo</Link>
-      <Link activeClassName="active" href="/bar">Bar</Link>
-    </nav>
-    <Router>
-      <div default>
-        this is a demo route that always matches
-      </div>
-    </Router>
-  </div>
-)
-```
-
-
-### Default Link Behavior
-
-Sometimes it's necessary to bypass preact-router's link handling and let the browser perform routing on its own.
-
-This can be accomplished by adding a `native` boolean attribute to any link:
-
-```html
-<a href="/foo" native>Foo</a>
-```
-
-### Detecting Route Changes
-
-The `Router` notifies you when a change event occurs for a route with the `onChange` callback:
-
-```js
-import { render, Component } from 'preact';
-import { Router, route } from 'preact-router';
-
-class App extends Component {
-
-  // some method that returns a promise
-  isAuthenticated() { }
-
-  handleRoute = async e => {
-    switch (e.url) {
-      case '/profile':
-        const isAuthed = await this.isAuthenticated();
-        if (!isAuthed) route('/', true);
-        break;
-    }
-  };
-
-  render() {
-    return (
-      <Router onChange={this.handleRoute}>
-        <Home path="/" />
-        <Profile path="/profile" />
-      </Router>
-    );
-  }
-
-}
-```
-
-### Redirects
-
-Can easily be implemented with a custom `Redirect` component;
-
-```js
-import { Component } from 'preact';
-import { route } from 'preact-router';
-
-export default class Redirect extends Component {
-  componentWillMount() {
-    route(this.props.to, true);
-  }
-
-  render() {
-    return null;
-  }
-}
-```
-
-Now to create a redirect within your application, you can add this `Redirect` component to your router;
-
-```js
-<Router>
-  <Bar path="/bar" />
-  <Redirect path="/foo" to="/bar" />
-</Router>
-```
-
-
-### Custom History
-
-It's possible to use alternative history bindings, like `/#!/hash-history`:
-
-```js
-import { h } from 'preact';
-import Router from 'preact-router';
-import { createHashHistory } from 'history';
-
-const Main = () => (
-    <Router history={createHashHistory()}>
-        <Home path="/" />
-        <About path="/about" />
-        <Search path="/search/:query" />
-    </Router>
-);
-
-render(<Main />, document.body);
-```
-
-### Programmatically Triggering Route
-
-Its possible to programmatically trigger a route to a page (like `window.location = '/page-2'`)
-
-```js
-import { route } from 'preact-router';
-
-route('/page-2')  // appends a history entry
-
-route('/page-3', true)  // replaces the current history entry
-```
-
-### License
-
-[MIT]
-
-
-[Preact]: https://github.com/developit/preact
-[MIT]: https://choosealicense.com/licenses/mit/

package/lib/preact-router/index.d.ts

@@ -1,71 +0,0 @@
-import * as preact from 'preact';
-
-export function route(url: string, replace?: boolean): boolean;
-export function route(options: { url: string; replace?: boolean }): boolean;
-
-export function getCurrentUrl(): string;
-
-export interface Location {
-    pathname: string;
-    search: string;
-}
-
-export interface CustomHistory {
-    listen(callback: (location: Location) => void): () => void;
-    location: Location;
-    push(path: string): void;
-    replace(path: string): void;
-}
-
-export interface RoutableProps {
-    path?: string;
-    default?: boolean;
-}
-
-export interface RouterOnChangeArgs {
-    router: Router;
-    url: string;
-    previous?: string;
-    active: preact.VNode[];
-    current: preact.VNode;
-}
-
-export interface RouterProps extends RoutableProps {
-    history?: CustomHistory;
-    static?: boolean;
-    url?: string;
-    onChange?: (args: RouterOnChangeArgs) => void;
-}
-
-export class Router extends preact.Component<RouterProps, {}> {
-    canRoute(url: string): boolean;
-    getMatchingChildren(
-        children: preact.VNode[],
-        url: string,
-        invoke: boolean
-    ): preact.VNode[];
-    routeTo(url: string): boolean;
-    render(props: RouterProps, {}): preact.VNode;
-}
-
-export const subscribers: Array<(url: string) => void>
-
-type AnyComponent<Props> =
-  | preact.FunctionalComponent<Props>
-  | preact.ComponentConstructor<Props, any>;
-
-export interface RouteProps<Props> extends RoutableProps {
-    component: AnyComponent<Props>;
-}
-
-export function Route<Props>(
-    props: RouteProps<Props> & Partial<Props>
-): preact.VNode;
-
-export function Link(props: {activeClassName?: string} & preact.JSX.HTMLAttributes): preact.VNode;
-
-declare module 'preact' {
-    export interface Attributes extends RoutableProps {}
-}
-
-export default Router;

package/lib/preact-router/match/index.d.ts

@@ -1,16 +0,0 @@
-import * as preact from 'preact';
-
-import { Link as StaticLink, RoutableProps } from '..';
-
-export class Match extends preact.Component<RoutableProps, {}> {
-    render(): preact.VNode;
-}
-
-export interface LinkProps extends preact.JSX.HTMLAttributes {
-    activeClassName?: string;
-    children?: preact.ComponentChildren;
-}
-
-export function Link(props: LinkProps): preact.VNode;
-
-export default Match;

package/lib/preact-router/match/package.json

@@ -1,13 +0,0 @@
-{
-	"name": "index",
-	"module": "./index.es.js",
-	"main": "./index.js",
-	"types": "./index.d.ts",
-	"scripts": {
-		"build": "microbundle src/index.js -f es -o . --no-sourcemap && microbundle src/cjs.js -f cjs -o . --no-sourcemap"
-	},
-	"peerDependencies": {
-		"preact": "*",
-		"preact-router": "*"
-	}
-}

package/lib/preact-router/match/src/cjs.js

@@ -1,4 +0,0 @@
-import { Match, Link } from './index';
-
-Match.Link = Link;
-export default Match;

package/lib/preact-router/match/src/index.js

@@ -1,36 +0,0 @@
-import { h, Component } from 'preact';
-import { subscribers, getCurrentUrl, Link as StaticLink, exec } from 'preact-router';
-
-export class Match extends Component {
-	componentDidMount() {
-		this.update = url => {
-			this.nextUrl = url;
-			this.setState({});
-		};
-		subscribers.push(this.update);
-	}
-	componentWillUnmount() {
-		subscribers.splice(subscribers.indexOf(this.update)>>>0, 1);
-	}
-	render(props) {
-		let url = this.nextUrl || getCurrentUrl(),
-			path = url.replace(/\?.+$/,'');
-		this.nextUrl = null;
-		return props.children({
-			url,
-			path,
-			matches: exec(path, props.path, {}) !== false
-		});
-	}
-}
-
-export const Link = ({ activeClassName, path, ...props }) => (
-	<Match path={path || props.href}>
-		{ ({ matches }) => {
-			let cls=[props.class || props.className, matches && activeClassName].filter(Boolean).join(' ');
-			return <StaticLink {...props} className={cls} />;
-		} }
-	</Match>
-);
-
-export default Match;