pixuireactcomponents 1.2.0 → 1.2.1

package/lib/preact-router/package.json

@@ -1,78 +0,0 @@
-{
-  "name": "preact-router",
-	"amdName": "preactRouter",
-	"version": "3.2.1",
-	"description": "Connect your components up to that address bar.",
-	"main": "dist/preact-router.js",
-	"umd:main": "dist/preact-router.umd.js",
-	"unpkg": "dist/preact-router.umd.js",
-	"jsnext:main": "dist/preact-router.es.js",
-	"module": "dist/preact-router.es.js",
-	"exports": {
-		".": {
-			"import": "./dist/preact-router.es.js",
-			"require": "./dist/preact-router.js"
-		},
-		"./match": {
-			"import": "./match/index.es.js",
-			"require": "./match/index.js"
-		},
-		"./package.json": "./package.json",
-		"./": "./"
-	},
-	"scripts": {
-		"build": "microbundle -f es,modern && microbundle src/cjs.js -f cjs,umd && (cd match && npm run build)",
-		"test": "npm-run-all lint build test:unit test:ts",
-		"lint": "eslint src test",
-		"fix": "npm run lint -- --fix",
-		"test:unit": "karmatic",
-		"test:ts": "tsc -p ./test",
-		"prepublishOnly": "npm-run-all build test",
-		"release": "npm run build && git commit -am $npm_package_version && git tag $npm_package_version && git push && git push --tags && npm publish"
-	},
-	"files": [
-		"src",
-		"dist",
-		"match",
-		"index.d.ts"
-	],
-	"typings": "./index.d.ts",
-	"keywords": [
-		"preact",
-		"router"
-	],
-	"author": "Jason Miller <jason@developit.ca>",
-	"license": "MIT",
-	"repository": "preactjs/preact-router",
-	"homepage": "https://github.com/preactjs/preact-router",
-	"eslintConfig": {
-		"rules": {
-			"jest/no-jasmine-globals": 0
-		},
-		"globals": {
-			"spyOn": "readonly"
-		}
-	},
-	"peerDependencies": {
-		"preact": ">=10"
-	},
-	"devDependencies": {
-		"@babel/plugin-transform-react-jsx": "^7.9.1",
-		"chai": "^3.5.0",
-		"copyfiles": "^1.0.0",
-		"eslint": "^6.8.0",
-		"eslint-config-preact": "^1.1.1",
-		"karmatic": "^1.4.0",
-		"microbundle": "^0.12.0-next.8",
-		"mkdirp": "^0.5.3",
-		"mocha": "^5.2.0",
-		"npm-merge-driver-install": "^1.1.1",
-		"npm-run-all": "^3.0.0",
-		"preact": "^10.3.4",
-		"rimraf": "^2.5.1",
-		"sinon": "^7.1.0",
-		"sinon-chai": "^2.8.0",
-		"typescript": "^3.4.4",
-		"webpack": "^4.42.0"
-	}
-}

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

@@ -1,11 +0,0 @@
-import { subscribers, getCurrentUrl, route, Router, Route, Link, exec } from './index';
-
-Router.subscribers = subscribers;
-Router.getCurrentUrl = getCurrentUrl;
-Router.route = route;
-Router.Router = Router;
-Router.Route = Route;
-Router.Link = Link;
-Router.exec = exec;
-
-export default Router;

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

@@ -1,270 +0,0 @@
-import { cloneElement, createElement, Component, toChildArray } from 'preact';
-import { exec, prepareVNodeForRanking, assign, pathRankSort } from './util';
-
-let customHistory = null;
-
-const ROUTERS = [];
-
-const subscribers = [];
-
-const EMPTY = {};
-
-function setUrl(url, type='push') {
-	if (customHistory && customHistory[type]) {
-		customHistory[type](url);
-	}
-	else if (typeof history!=='undefined' && history[type+'State']) {
-		console.log('---------------',type);
-		history[type+'State'](null, null, url);
-	}
-	else{
-		// console.log('!!!!!!!!!!!!',type,history,history.pushState,browser_location.pushState);
-
-	}
-}
-
-
-function getCurrentUrl() {
-	let url;
-	if (customHistory && customHistory.location) {
-		url = customHistory.location;
-	}
-	else if (customHistory && customHistory.getCurrentLocation) {
-		url = customHistory.getCurrentLocation();
-	}
-	else {
-		url = typeof location!=='undefined' ? location : EMPTY;
-	}
-	return `${url.pathname || ''}${url.search || ''}`;
-}
-
-
-
-function route(url, replace=false) {
-	if (typeof url!=='string' && url.url) {
-		replace = url.replace;
-		url = url.url;
-	}
-
-	// only push URL into history if we can handle it
-	if (canRoute(url)) {
-		setUrl(url, replace ? 'replace' : 'push');
-	}
-
-	return routeTo(url);
-}
-
-
-/** Check if the given URL can be handled by any router instances. */
-function canRoute(url) {
-	for (let i=ROUTERS.length; i--; ) {
-		if (ROUTERS[i].canRoute(url)) return true;
-	}
-	return false;
-}
-
-
-/** Tell all router instances to handle the given URL.  */
-function routeTo(url) {
-	let didRoute = false;
-	for (let i=0; i<ROUTERS.length; i++) {
-		if (ROUTERS[i].routeTo(url)===true) {
-			didRoute = true;
-		}
-	}
-	for (let i=subscribers.length; i--; ) {
-		subscribers[i](url);
-	}
-	return didRoute;
-}
-
-
-function routeFromLink(node) {
-	// only valid elements
-	if (!node || !node.getAttribute) return;
-
-	let href = node.getAttribute('href'),
-		target = node.getAttribute('target');
-
-	// ignore links with targets and non-path URLs
-	if (!href || !href.match(/^\//g) || (target && !target.match(/^_?self$/i))) {
-		console.log('bypass routeFromLink', href,target);
-		return;
-	}
-
-	// attempt to route, if no match simply cede control to browser
-	return route(href);
-}
-
-
-function handleLinkClick(e) {
-	if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.button!==0) {
-		console.log('bypass handleLinkClick', e.button);
-		return;
-	}
-
-	routeFromLink(e.currentTarget || e.target || this);
-	return prevent(e);
-}
-
-
-function prevent(e) {
-	if (e) {
-		if (e.stopImmediatePropagation) e.stopImmediatePropagation();
-		if (e.stopPropagation) e.stopPropagation();
-		e.preventDefault();
-	}
-	return false;
-}
-
-
-function delegateLinkHandler(e) {
-	// console.log('delegateLinkHandler',e.button,e.target.nodeName);
-	// ignore events the browser takes care of already:
-	if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.button!==0) return;
-
-	let t = e.target;
-	do {
-		if (String(t.nodeName).toUpperCase()==='A' && t.getAttribute('href')) {
-			if (t.hasAttribute('native')) return;
-			// if link is handled by the router, prevent browser defaults
-			if (routeFromLink(t)) {
-				return prevent(e);
-			}
-		}
-	} while ((t=t.parentNode));
-}
-
-
-let eventListenersInitialized = false;
-
-function initEventListeners() {
-	if (eventListenersInitialized) return;
-
-	if (typeof addEventListener==='function') {
-		if (!customHistory) {
-			addEventListener('popstate', () => {
-				routeTo(getCurrentUrl());
-			});
-		}
-			addEventListener('click', delegateLinkHandler);
-	}
-	eventListenersInitialized = true;
-}
-
-
-class Router extends Component {
-	constructor(props) {
-		super(props);
-		if (props.history) {
-			customHistory = props.history;
-		}
-
-		this.state = {
-			url: props.url || getCurrentUrl()
-		};
-
-		initEventListeners();
-	}
-
-	shouldComponentUpdate(props) {
-		if (props.static!==true) return true;
-		return props.url!==this.props.url || props.onChange!==this.props.onChange;
-	}
-
-	/** Check if the given URL can be matched against any children */
-	canRoute(url) {
-		const children = toChildArray(this.props.children);
-		return this.getMatchingChildren(children, url, false).length > 0;
-	}
-
-	/** Re-render children with a new URL to match against. */
-	routeTo(url) {
-		this.setState({ url });
-
-		const didRoute = this.canRoute(url);
-
-		// trigger a manual re-route if we're not in the middle of an update:
-		if (!this.updating) this.forceUpdate();
-
-		return didRoute;
-	}
-
-	componentWillMount() {
-		ROUTERS.push(this);
-		this.updating = true;
-	}
-
-	componentDidMount() {
-		if (customHistory) {
-			this.unlisten = customHistory.listen((location) => {
-				this.routeTo(`${location.pathname || ''}${location.search || ''}`);
-			});
-		}
-		this.updating = false;
-	}
-
-	componentWillUnmount() {
-		if (typeof this.unlisten==='function') this.unlisten();
-		ROUTERS.splice(ROUTERS.indexOf(this), 1);
-	}
-
-	componentWillUpdate() {
-		this.updating = true;
-	}
-
-	componentDidUpdate() {
-		this.updating = false;
-	}
-
-	getMatchingChildren(children, url, invoke) {
-		return children
-			.filter(prepareVNodeForRanking)
-			.sort(pathRankSort)
-			.map( vnode => {
-				let matches = exec(url, vnode.props.path, vnode.props);
-				if (matches) {
-					if (invoke !== false) {
-						let newProps = { url, matches };
-						assign(newProps, matches);
-						delete newProps.ref;
-						delete newProps.key;
-						return cloneElement(vnode, newProps);
-					}
-					return vnode;
-				}
-			}).filter(Boolean);
-	}
-
-	render({ children, onChange }, { url }) {
-		console.log('router state',url);
-		let active = this.getMatchingChildren(toChildArray(children), url, true);
-
-		let current = active[0] || null;
-
-		let previous = this.previousUrl;
-		if (url!==previous) {
-			this.previousUrl = url;
-			if (typeof onChange==='function') {
-				onChange({
-					router: this,
-					url,
-					previous,
-					active,
-					current
-				});
-			}
-		}
-
-		return current;
-	}
-}
-
-const Link = (props) => (
-	createElement('a', assign({ onClick: handleLinkClick }, props))
-);
-
-const Route = props => createElement(props.component, props);
-
-export { subscribers, getCurrentUrl, route, Router, Route, Link, exec };
-export default Router;

package/lib/preact-router/src/util.js

@@ -1,87 +0,0 @@
-
-const EMPTY = {};
-
-export function assign(obj, props) {
-	// eslint-disable-next-line guard-for-in
-	for (let i in props) {
-		obj[i] = props[i];
-	}
-	return obj;
-}
-
-export function exec(url, route, opts) {
-	let reg = /(?:\?([^#]*))?(#.*)?$/,
-		c = url.match(reg),
-		matches = {},
-		ret;
-	if (c && c[1]) {
-		let p = c[1].split('&');
-		for (let i=0; i<p.length; i++) {
-			let r = p[i].split('=');
-			matches[decodeURIComponent(r[0])] = decodeURIComponent(r.slice(1).join('='));
-		}
-	}
-	url = segmentize(url.replace(reg, ''));
-	route = segmentize(route || '');
-
-	let max = Math.min(url.length, route.length);
-	if(route.length>url.length)
-		max = route.length;
-
-	for (let i=0; i<max; i++) {
-		if (route[i] && route[i].charAt(0)===':') {
-			let param = route[i].replace(/(^:|[+*?]+$)/g, ''),
-				flags = (route[i].match(/[+*?]+$/) || EMPTY)[0] || '',
-				plus = ~flags.indexOf('+'),
-				star = ~flags.indexOf('*'),
-				val = url[i] || '';
-			if (!val && !star && (flags.indexOf('?')<0 || plus)) {
-				ret = false;
-				break;
-			}
-			matches[param] = decodeURIComponent(val);
-			if (plus || star) {
-				matches[param] = url.slice(i).map(decodeURIComponent).join('/');
-				break;
-			}
-		}
-		else if (route[i]!==url[i]) {
-			ret = false;
-			break;
-		}
-	}
-	// console.log('exec',url,route,opts,ret);
-	if (opts.default!==true && ret===false) return false;
-	return matches;
-}
-
-export function pathRankSort(a, b) {
-	return (
-		(a.rank < b.rank) ? 1 :
-			(a.rank > b.rank) ? -1 :
-				(a.index - b.index)
-	);
-}
-
-// filter out VNodes without attributes (which are unrankeable), and add `index`/`rank` properties to be used in sorting.
-export function prepareVNodeForRanking(vnode, index) {
-	vnode.index = index;
-	vnode.rank = rankChild(vnode);
-	return vnode.props;
-}
-
-export function segmentize(url) {
-	return url.replace(/(^\/+|\/+$)/g, '').split('/');
-}
-
-export function rankSegment(segment) {
-	return segment.charAt(0)==':' ? (1 + '*+?'.indexOf(segment.charAt(segment.length-1))) || 4 : 5;
-}
-
-export function rank(path) {
-	return segmentize(path).map(rankSegment).join('');
-}
-
-function rankChild(vnode) {
-	return vnode.props.default ? 0 : rank(vnode.props.path);
-}

package/lib/react-window/src/FixedSizeGrid.js

@@ -1,244 +0,0 @@
-// @flow
-
-import createGridComponent from './createGridComponent';
-
-import type { Props, ScrollToAlign } from './createGridComponent';
-
-const FixedSizeGrid = createGridComponent({
-  getColumnOffset: ({ columnWidth }: Props<any>, index: number): number =>
-    index * ((columnWidth: any): number),
-
-  getColumnWidth: ({ columnWidth }: Props<any>, index: number): number =>
-    ((columnWidth: any): number),
-
-  getRowOffset: ({ rowHeight }: Props<any>, index: number): number =>
-    index * ((rowHeight: any): number),
-
-  getRowHeight: ({ rowHeight }: Props<any>, index: number): number =>
-    ((rowHeight: any): number),
-
-  getEstimatedTotalHeight: ({ rowCount, rowHeight }: Props<any>) =>
-    ((rowHeight: any): number) * rowCount,
-
-  getEstimatedTotalWidth: ({ columnCount, columnWidth }: Props<any>) =>
-    ((columnWidth: any): number) * columnCount,
-
-  getOffsetForColumnAndAlignment: (
-    { columnCount, columnWidth, width }: Props<any>,
-    columnIndex: number,
-    align: ScrollToAlign,
-    scrollLeft: number,
-    instanceProps: typeof undefined,
-    scrollbarSize: number
-  ): number => {
-    const lastColumnOffset = Math.max(
-      0,
-      columnCount * ((columnWidth: any): number) - width
-    );
-    const maxOffset = Math.min(
-      lastColumnOffset,
-      columnIndex * ((columnWidth: any): number)
-    );
-    const minOffset = Math.max(
-      0,
-      columnIndex * ((columnWidth: any): number) -
-        width +
-        scrollbarSize +
-        ((columnWidth: any): number)
-    );
-
-    if (align === 'smart') {
-      if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
-        align = 'auto';
-      } else {
-        align = 'center';
-      }
-    }
-
-    switch (align) {
-      case 'start':
-        return maxOffset;
-      case 'end':
-        return minOffset;
-      case 'center':
-        // "Centered" offset is usually the average of the min and max.
-        // But near the edges of the list, this doesn't hold true.
-        const middleOffset = Math.round(
-          minOffset + (maxOffset - minOffset) / 2
-        );
-        if (middleOffset < Math.ceil(width / 2)) {
-          return 0; // near the beginning
-        } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
-          return lastColumnOffset; // near the end
-        } else {
-          return middleOffset;
-        }
-      case 'auto':
-      default:
-        if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
-          return scrollLeft;
-        } else if (minOffset > maxOffset) {
-          // Because we only take into account the scrollbar size when calculating minOffset
-          // this value can be larger than maxOffset when at the end of the list
-          return minOffset;
-        } else if (scrollLeft < minOffset) {
-          return minOffset;
-        } else {
-          return maxOffset;
-        }
-    }
-  },
-
-  getOffsetForRowAndAlignment: (
-    { rowHeight, height, rowCount }: Props<any>,
-    rowIndex: number,
-    align: ScrollToAlign,
-    scrollTop: number,
-    instanceProps: typeof undefined,
-    scrollbarSize: number
-  ): number => {
-    const lastRowOffset = Math.max(
-      0,
-      rowCount * ((rowHeight: any): number) - height
-    );
-    const maxOffset = Math.min(
-      lastRowOffset,
-      rowIndex * ((rowHeight: any): number)
-    );
-    const minOffset = Math.max(
-      0,
-      rowIndex * ((rowHeight: any): number) -
-        height +
-        scrollbarSize +
-        ((rowHeight: any): number)
-    );
-
-    if (align === 'smart') {
-      if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
-        align = 'auto';
-      } else {
-        align = 'center';
-      }
-    }
-
-    switch (align) {
-      case 'start':
-        return maxOffset;
-      case 'end':
-        return minOffset;
-      case 'center':
-        // "Centered" offset is usually the average of the min and max.
-        // But near the edges of the list, this doesn't hold true.
-        const middleOffset = Math.round(
-          minOffset + (maxOffset - minOffset) / 2
-        );
-        if (middleOffset < Math.ceil(height / 2)) {
-          return 0; // near the beginning
-        } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
-          return lastRowOffset; // near the end
-        } else {
-          return middleOffset;
-        }
-      case 'auto':
-      default:
-        if (scrollTop >= minOffset && scrollTop <= maxOffset) {
-          return scrollTop;
-        } else if (minOffset > maxOffset) {
-          // Because we only take into account the scrollbar size when calculating minOffset
-          // this value can be larger than maxOffset when at the end of the list
-          return minOffset;
-        } else if (scrollTop < minOffset) {
-          return minOffset;
-        } else {
-          return maxOffset;
-        }
-    }
-  },
-
-  getColumnStartIndexForOffset: (
-    { columnWidth, columnCount }: Props<any>,
-    scrollLeft: number
-  ): number =>
-    Math.max(
-      0,
-      Math.min(
-        columnCount - 1,
-        Math.floor(scrollLeft / ((columnWidth: any): number))
-      )
-    ),
-
-  getColumnStopIndexForStartIndex: (
-    { columnWidth, columnCount, width }: Props<any>,
-    startIndex: number,
-    scrollLeft: number
-  ): number => {
-    const left = startIndex * ((columnWidth: any): number);
-    const numVisibleColumns = Math.ceil(
-      (width + scrollLeft - left) / ((columnWidth: any): number)
-    );
-    return Math.max(
-      0,
-      Math.min(
-        columnCount - 1,
-        startIndex + numVisibleColumns - 1 // -1 is because stop index is inclusive
-      )
-    );
-  },
-
-  getRowStartIndexForOffset: (
-    { rowHeight, rowCount }: Props<any>,
-    scrollTop: number
-  ): number =>
-    Math.max(
-      0,
-      Math.min(rowCount - 1, Math.floor(scrollTop / ((rowHeight: any): number)))
-    ),
-
-  getRowStopIndexForStartIndex: (
-    { rowHeight, rowCount, height }: Props<any>,
-    startIndex: number,
-    scrollTop: number
-  ): number => {
-    const top = startIndex * ((rowHeight: any): number);
-    const numVisibleRows = Math.ceil(
-      (height + scrollTop - top) / ((rowHeight: any): number)
-    );
-    return Math.max(
-      0,
-      Math.min(
-        rowCount - 1,
-        startIndex + numVisibleRows - 1 // -1 is because stop index is inclusive
-      )
-    );
-  },
-
-  initInstanceProps(props: Props<any>): any {
-    // Noop
-  },
-
-  shouldResetStyleCacheOnItemSizeChange: true,
-
-  validateProps: ({ columnWidth, rowHeight }: Props<any>): void => {
-    if (process.env.NODE_ENV !== 'production') {
-      if (typeof columnWidth !== 'number') {
-        throw Error(
-          'An invalid "columnWidth" prop has been specified. ' +
-            'Value should be a number. ' +
-            `"${
-              columnWidth === null ? 'null' : typeof columnWidth
-            }" was specified.`
-        );
-      }
-
-      if (typeof rowHeight !== 'number') {
-        throw Error(
-          'An invalid "rowHeight" prop has been specified. ' +
-            'Value should be a number. ' +
-            `"${rowHeight === null ? 'null' : typeof rowHeight}" was specified.`
-        );
-      }
-    }
-  },
-});
-
-export default FixedSizeGrid;