@pixui-dev/pxw 0.1.16

package/lib/pika-svelte/motion/index.js

@@ -0,0 +1,210 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var store = require('../store/index.js');
+var internal = require('../internal/index.js');
+var easing = require('../easing/index.js');
+
+function is_date(obj) {
+	return Object.prototype.toString.call(obj) === '[object Date]';
+}
+
+function tick_spring(ctx, last_value, current_value, target_value) {
+	if (typeof current_value === 'number' || is_date(current_value)) {
+		// @ts-ignore
+		const delta = target_value - current_value;
+		// @ts-ignore
+		const velocity = (current_value - last_value) / (ctx.dt || 1 / 60); // guard div by 0
+		const spring = ctx.opts.stiffness * delta;
+		const damper = ctx.opts.damping * velocity;
+		const acceleration = (spring - damper) * ctx.inv_mass;
+		const d = (velocity + acceleration) * ctx.dt;
+		if (Math.abs(d) < ctx.opts.precision && Math.abs(delta) < ctx.opts.precision) {
+			return target_value; // settled
+		}
+		else {
+			ctx.settled = false; // signal loop to keep ticking
+			// @ts-ignore
+			return is_date(current_value) ? new Date(current_value.getTime() + d) : current_value + d;
+		}
+	}
+	else if (Array.isArray(current_value)) {
+		// @ts-ignore
+		return current_value.map((_, i) => tick_spring(ctx, last_value[i], current_value[i], target_value[i]));
+	}
+	else if (typeof current_value === 'object') {
+		const next_value = {};
+		for (const k in current_value) {
+			// @ts-ignore
+			next_value[k] = tick_spring(ctx, last_value[k], current_value[k], target_value[k]);
+		}
+		// @ts-ignore
+		return next_value;
+	}
+	else {
+		throw new Error(`Cannot spring ${typeof current_value} values`);
+	}
+}
+function spring(value, opts = {}) {
+	const store$1 = store.writable(value);
+	const { stiffness = 0.15, damping = 0.8, precision = 0.01 } = opts;
+	let last_time;
+	let task;
+	let current_token;
+	let last_value = value;
+	let target_value = value;
+	let inv_mass = 1;
+	let inv_mass_recovery_rate = 0;
+	let cancel_task = false;
+	function set(new_value, opts = {}) {
+		target_value = new_value;
+		const token = (current_token = {});
+		if (value == null || opts.hard || (spring.stiffness >= 1 && spring.damping >= 1)) {
+			cancel_task = true; // cancel any running animation
+			last_time = internal.now();
+			last_value = new_value;
+			store$1.set((value = target_value));
+			return Promise.resolve();
+		}
+		else if (opts.soft) {
+			const rate = opts.soft === true ? 0.5 : +opts.soft;
+			inv_mass_recovery_rate = 1 / (rate * 60);
+			inv_mass = 0; // infinite mass, unaffected by spring forces
+		}
+		if (!task) {
+			last_time = internal.now();
+			cancel_task = false;
+			task = internal.loop((now) => {
+				if (cancel_task) {
+					cancel_task = false;
+					task = null;
+					return false;
+				}
+				inv_mass = Math.min(inv_mass + inv_mass_recovery_rate, 1);
+				const ctx = {
+					inv_mass,
+					opts: spring,
+					settled: true,
+					dt: ((now - last_time) * 60) / 1000,
+				};
+				const next_value = tick_spring(ctx, last_value, value, target_value);
+				last_time = now;
+				last_value = value;
+				store$1.set((value = next_value));
+				if (ctx.settled) {
+					task = null;
+				}
+				return !ctx.settled;
+			});
+		}
+		return new Promise((fulfil) => {
+			task.promise.then(() => {
+				if (token === current_token) fulfil();
+			});
+		});
+	}
+	const spring = {
+		set,
+		update: (fn, opts) => set(fn(target_value, value), opts),
+		subscribe: store$1.subscribe,
+		stiffness,
+		damping,
+		precision,
+	};
+	return spring;
+}
+
+function get_interpolator(a, b) {
+	if (a === b || a !== a) return () => a;
+	const type = typeof a;
+	if (type !== typeof b || Array.isArray(a) !== Array.isArray(b)) {
+		throw new Error('Cannot interpolate values of different type');
+	}
+	if (Array.isArray(a)) {
+		const arr = b.map((bi, i) => {
+			return get_interpolator(a[i], bi);
+		});
+		return (t) => arr.map((fn) => fn(t));
+	}
+	if (type === 'object') {
+		if (!a || !b) throw new Error('Object cannot be null');
+		if (is_date(a) && is_date(b)) {
+			a = a.getTime();
+			b = b.getTime();
+			const delta = b - a;
+			return (t) => new Date(a + t * delta);
+		}
+		const keys = Object.keys(b);
+		const interpolators = {};
+		keys.forEach((key) => {
+			interpolators[key] = get_interpolator(a[key], b[key]);
+		});
+		return (t) => {
+			const result = {};
+			keys.forEach((key) => {
+				result[key] = interpolators[key](t);
+			});
+			return result;
+		};
+	}
+	if (type === 'number') {
+		const delta = b - a;
+		return (t) => a + t * delta;
+	}
+	throw new Error(`Cannot interpolate ${type} values`);
+}
+function tweened(value, defaults = {}) {
+	const store$1 = store.writable(value);
+	let task;
+	let target_value = value;
+	function set(new_value, opts) {
+		if (value == null) {
+			store$1.set((value = new_value));
+			return Promise.resolve();
+		}
+		target_value = new_value;
+		let previous_task = task;
+		let started = false;
+		let { delay = 0, duration = 400, easing: easing$1 = easing.linear, interpolate = get_interpolator } = internal.assign(internal.assign({}, defaults), opts);
+		if (duration === 0) {
+			if (previous_task) {
+				previous_task.abort();
+				previous_task = null;
+			}
+			store$1.set((value = target_value));
+			return Promise.resolve();
+		}
+		const start = internal.now() + delay;
+		let fn;
+		task = internal.loop((now) => {
+			if (now < start) return true;
+			if (!started) {
+				fn = interpolate(value, new_value);
+				if (typeof duration === 'function') duration = duration(value, new_value);
+				started = true;
+			}
+			if (previous_task) {
+				previous_task.abort();
+				previous_task = null;
+			}
+			const elapsed = now - start;
+			if (elapsed > duration) {
+				store$1.set((value = new_value));
+				return false;
+			}
+			// @ts-ignore
+			store$1.set((value = fn(easing$1(elapsed / duration))));
+			return true;
+		});
+		return task.promise;
+	}
+	return {
+		set,
+		update: (fn, opts) => set(fn(target_value, value), opts),
+		subscribe: store$1.subscribe,
+	};
+}
+
+exports.spring = spring;
+exports.tweened = tweened;

package/lib/pika-svelte/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "svelte",
+  "version": "1.0.7",
+  "description": "Cybernetically enhanced pixui apps",
+  "module": "index.mjs",
+  "private": true,
+  "main": "index",
+  "files": [
+    "types",
+    "compiler.*",
+    "register.js",
+    "index.*",
+    "internal",
+    "store",
+    "animate",
+    "transition",
+    "easing",
+    "motion",
+    "svelte",
+    "README.md"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    },
+    "./compiler": {
+      "import": "./compiler.mjs",
+      "require": "./compiler.js"
+    },
+    "./animate": {
+      "import": "./animate/index.mjs",
+      "require": "./animate/index.js"
+    },
+    "./easing": {
+      "import": "./easing/index.mjs",
+      "require": "./easing/index.js"
+    },
+    "./internal": {
+      "import": "./internal/index.mjs",
+      "require": "./internal/index.js"
+    },
+    "./motion": {
+      "import": "./motion/index.mjs",
+      "require": "./motion/index.js"
+    },
+    "./register": {
+      "require": "./register.js"
+    },
+    "./store": {
+      "import": "./store/index.mjs",
+      "require": "./store/index.js"
+    },
+    "./transition": {
+      "import": "./transition/index.mjs",
+      "require": "./transition/index.js"
+    }
+  },
+  "engines": {
+    "node": ">= 8"
+  },
+  "types": "types/runtime/index.d.ts",
+  "scripts": {
+    "test": "mocha",
+    "test:unit": "mocha --require sucrase/register --recursive src/**/__test__.ts",
+    "quicktest": "mocha",
+    "precoverage": "c8 mocha",
+    "coverage": "c8 report --reporter=text-lcov > coverage.lcov && c8 report --reporter=html",
+    "codecov": "codecov",
+    "precodecov": "npm run coverage",
+    "build": "PUBLISH=true rollup -c && npm run tsd",
+    "prepare": "npm run build",
+    "dev": "rollup -cw",
+    "pretest": "npm run build",
+    "posttest": "agadoo internal/index.mjs",
+    "prepublishOnly": "npm run lint",
+    "tsd": "tsc -p src/compiler --emitDeclarationOnly && tsc -p src/runtime --emitDeclarationOnly",
+    "lint": "eslint \"{src,test}/**/*.{ts,js}\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.code.oa.com/WGFE/pika-svelte"
+  },
+  "keywords": [
+    "UI",
+    "framework",
+    "templates",
+    "templating"
+  ],
+  "author": "Rich Harris",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sveltejs/svelte/issues"
+  },
+  "homepage": "https://github.com/sveltejs/svelte#README",
+  "devDependencies": {
+    "@ampproject/remapping": "^0.3.0",
+    "@rollup/plugin-commonjs": "^11.0.0",
+    "@rollup/plugin-json": "^4.0.1",
+    "@rollup/plugin-node-resolve": "^6.0.0",
+    "@rollup/plugin-replace": "^2.3.0",
+    "@rollup/plugin-sucrase": "^3.1.0",
+    "@rollup/plugin-typescript": "^2.0.1",
+    "@rollup/plugin-virtual": "^2.0.0",
+    "@sveltejs/eslint-config": "github:sveltejs/eslint-config#v5.6.0",
+    "@types/mocha": "^7.0.0",
+    "@types/node": "^8.10.53",
+    "@typescript-eslint/eslint-plugin": "^4.9.0",
+    "@typescript-eslint/parser": "^4.9.0",
+    "acorn": "^7.4.0",
+    "agadoo": "^1.1.0",
+    "c8": "^5.0.1",
+    "code-red": "^0.1.4",
+    "codecov": "^3.5.0",
+    "css-tree": "1.0.0-alpha22",
+    "eslint": "^7.15.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-svelte3": "^2.7.3",
+    "estree-walker": "^1.0.0",
+    "is-reference": "^1.1.4",
+    "jsdom": "^15.1.1",
+    "kleur": "^3.0.3",
+    "locate-character": "^2.0.5",
+    "magic-string": "^0.25.3",
+    "mocha": "^7.0.0",
+    "periscopic": "^2.0.1",
+    "puppeteer": "^2.1.1",
+    "rollup": "^1.27.14",
+    "source-map": "^0.7.3",
+    "source-map-support": "^0.5.13",
+    "sourcemap-codec": "^1.4.8",
+    "tiny-glob": "^0.2.6",
+    "tslib": "^2.0.3",
+    "typescript": "^3.7.5"
+  },
+  "nyc": {
+    "include": [
+      "compiler/svelte.js",
+      "shared.js"
+    ],
+    "sourceMap": true,
+    "instrument": true
+  }
+}

package/lib/pika-svelte/register.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+const { compile } = require('./compiler.js');
+
+const extensions = ['.svelte', '.html'];
+let compileOptions = {};
+
+function capitalise(name) {
+	return name[0].toUpperCase() + name.slice(1);
+}
+
+function register(options = {}) {
+	if (options.extensions) {
+		extensions.forEach(deregisterExtension);
+		options.extensions.forEach(registerExtension);
+	}
+
+	compileOptions = Object.assign({}, options);
+	delete compileOptions.extensions;
+}
+
+function deregisterExtension(extension) {
+	delete require.extensions[extension];
+}
+
+function registerExtension(extension) {
+	require.extensions[extension] = function (module, filename) {
+		const name = path
+			.parse(filename)
+			.name.replace(/^\d/, '_$&')
+			.replace(/[^a-zA-Z0-9_$]/g, '');
+
+		const options = Object.assign({}, compileOptions, {
+			filename,
+			name: capitalise(name),
+			generate: 'ssr',
+			format: 'cjs',
+		});
+
+		const { js, warnings } = compile(fs.readFileSync(filename, 'utf-8'), options);
+
+		if (options.dev) {
+			warnings.forEach((warning) => {
+				console.warn(`\nSvelte Warning in ${warning.filename}:`);
+				console.warn(warning.message);
+				console.warn(warning.frame);
+			});
+		}
+
+		return module._compile(js.code, filename);
+	};
+}
+
+registerExtension('.svelte');
+registerExtension('.html');
+
+module.exports = register;

package/lib/pika-svelte/rollup.config.js

@@ -0,0 +1,126 @@
+import fs from 'fs';
+import replace from '@rollup/plugin-replace';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+import sucrase from '@rollup/plugin-sucrase';
+import typescript from '@rollup/plugin-typescript';
+import pkg from './package.json';
+
+const is_publish = !!process.env.PUBLISH;
+
+const ts_plugin = is_publish
+	? typescript({
+		include: 'src/**',
+		typescript: require('typescript'),
+	  })
+	: sucrase({
+		transforms: ['typescript'],
+	  });
+
+const external = (id) => id.startsWith('svelte/');
+
+fs.writeFileSync('./compiler.d.ts', 'export { compile, parse, preprocess, walk, VERSION } from \'./types/compiler/index\';');
+
+export default [
+	/* runtime */
+	{
+		input: 'src/runtime/index.ts',
+		output: [
+			{
+				file: 'index.mjs',
+				format: 'esm',
+				paths: (id) => id.startsWith('svelte/') && `${id.replace('svelte', '.')}/index.mjs`,
+			},
+			{
+				file: 'index.js',
+				format: 'cjs',
+				paths: (id) => id.startsWith('svelte/') && `${id.replace('svelte', '.')}/index.js`,
+			},
+		],
+		external,
+		plugins: [ts_plugin],
+	},
+
+	...fs
+		.readdirSync('src/runtime')
+		.filter((dir) => fs.statSync(`src/runtime/${dir}`).isDirectory())
+		.map((dir) => ({
+			input: `src/runtime/${dir}/index.ts`,
+			output: [
+				{
+					file: `${dir}/index.mjs`,
+					format: 'esm',
+					paths: (id) => id.startsWith('svelte/') && `${id.replace('svelte', '..')}/index.mjs`,
+				},
+				{
+					file: `${dir}/index.js`,
+					format: 'cjs',
+					paths: (id) => id.startsWith('svelte/') && `${id.replace('svelte', '..')}/index.js`,
+				},
+			],
+			external,
+			plugins: [
+				replace({
+					__VERSION__: pkg.version,
+				}),
+				ts_plugin,
+				{
+					writeBundle(bundle) {
+						if (dir === 'internal') {
+							const mod = bundle['index.mjs'];
+							if (mod) {
+								fs.writeFileSync('src/compiler/compile/internal_exports.ts', `// This file is automatically generated\nexport default new Set(${JSON.stringify(mod.exports)});`);
+							}
+						}
+
+						fs.writeFileSync(
+							`${dir}/package.json`,
+							JSON.stringify(
+								{
+									main: './index',
+									module: './index.mjs',
+									types: './index.d.ts',
+								},
+								null,
+								'  ',
+							),
+						);
+
+						fs.writeFileSync(`${dir}/index.d.ts`, `export * from '../types/runtime/${dir}/index';`);
+					},
+				},
+			],
+		})),
+
+	/* compiler.js */
+	{
+		input: 'src/compiler/index.ts',
+		plugins: [
+			replace({
+				__VERSION__: pkg.version,
+			}),
+			resolve(),
+			commonjs({
+				include: ['node_modules/**'],
+			}),
+			json(),
+			ts_plugin,
+		],
+		output: [
+			{
+				file: 'compiler.js',
+				format: is_publish ? 'umd' : 'cjs',
+				name: 'svelte',
+				sourcemap: true,
+			},
+			{
+				file: 'compiler.mjs',
+				format: 'esm',
+				name: 'svelte',
+				sourcemap: true,
+			},
+		],
+		external: is_publish ? [] : (id) => id === 'acorn' || id === 'magic-string' || id.startsWith('css-tree'),
+	},
+];

package/lib/pika-svelte/store/index.js

@@ -0,0 +1,123 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var internal = require('../internal/index.js');
+
+const subscriber_queue = [];
+/**
+ * Creates a `Readable` store that allows reading by subscription.
+ * @param value initial value
+ * @param {StartStopNotifier}start start and stop notifications for subscriptions
+ */
+function readable(value, start) {
+	return {
+		subscribe: writable(value, start).subscribe,
+	};
+}
+/**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+function writable(value, start = internal.noop) {
+	let stop;
+	const subscribers = [];
+	function set(new_value) {
+		if (internal.safe_not_equal(value, new_value)) {
+			value = new_value;
+			if (stop) {
+				// store is ready
+				const run_queue = !subscriber_queue.length;
+				for (let i = 0; i < subscribers.length; i += 1) {
+					const s = subscribers[i];
+					s[1]();
+					subscriber_queue.push(s, value);
+				}
+				if (run_queue) {
+					for (let i = 0; i < subscriber_queue.length; i += 2) {
+						subscriber_queue[i][0](subscriber_queue[i + 1]);
+					}
+					subscriber_queue.length = 0;
+				}
+			}
+		}
+	}
+	function update(fn) {
+		set(fn(value));
+	}
+	function subscribe(run, invalidate = internal.noop) {
+		const subscriber = [run, invalidate];
+		subscribers.push(subscriber);
+		if (subscribers.length === 1) {
+			stop = start(set) || internal.noop;
+		}
+		run(value);
+		return () => {
+			const index = subscribers.indexOf(subscriber);
+			if (index !== -1) {
+				subscribers.splice(index, 1);
+			}
+			if (subscribers.length === 0) {
+				stop();
+				stop = null;
+			}
+		};
+	}
+	return { set, update, subscribe };
+}
+function derived(stores, fn, initial_value) {
+	const single = !Array.isArray(stores);
+	const stores_array = single ? [stores] : stores;
+	const auto = fn.length < 2;
+	return readable(initial_value, (set) => {
+		let inited = false;
+		const values = [];
+		let pending = 0;
+		let cleanup = internal.noop;
+		const sync = () => {
+			if (pending) {
+				return;
+			}
+			cleanup();
+			const result = fn(single ? values[0] : values, set);
+			if (auto) {
+				set(result);
+			}
+			else {
+				cleanup = internal.is_function(result) ? result : internal.noop;
+			}
+		};
+		const unsubscribers = stores_array.map((store, i) =>
+			internal.subscribe(
+				store,
+				(value) => {
+					values[i] = value;
+					pending &= ~(1 << i);
+					if (inited) {
+						sync();
+					}
+				},
+				() => {
+					pending |= 1 << i;
+				},
+			),
+		);
+		inited = true;
+		sync();
+		return function stop() {
+			internal.run_all(unsubscribers);
+			cleanup();
+		};
+	});
+}
+
+Object.defineProperty(exports, 'get', {
+	enumerable: true,
+	get: function () {
+		return internal.get_store_value;
+	},
+});
+exports.derived = derived;
+exports.readable = readable;
+exports.writable = writable;