create-jen-app 0.1.0

package/templates/static/node_modules/preact/package.json

@@ -0,0 +1,258 @@
+{
+  "name": "preact",
+  "amdName": "preact",
+  "version": "10.28.3",
+  "private": false,
+  "description": "Fast 3kb React-compatible Virtual DOM library.",
+  "main": "dist/preact.js",
+  "module": "dist/preact.module.js",
+  "umd:main": "dist/preact.umd.js",
+  "unpkg": "dist/preact.min.js",
+  "source": "src/index.js",
+  "typesVersions": {
+    "<=5.0": {
+      ".": ["./src/index-5.d.ts"]
+    }
+  },
+  "exports": {
+    ".": {
+      "types@<=5.0": {
+        "types": "./src/index-5.d.ts"
+      },
+      "types": "./src/index.d.ts",
+      "browser": "./dist/preact.module.js",
+      "umd": "./dist/preact.umd.js",
+      "import": "./dist/preact.mjs",
+      "require": "./dist/preact.js"
+    },
+    "./compat": {
+      "types": "./compat/src/index.d.ts",
+      "browser": "./compat/dist/compat.module.js",
+      "umd": "./compat/dist/compat.umd.js",
+      "import": "./compat/dist/compat.mjs",
+      "require": "./compat/dist/compat.js"
+    },
+    "./debug": {
+      "types": "./debug/src/index.d.ts",
+      "browser": "./debug/dist/debug.module.js",
+      "umd": "./debug/dist/debug.umd.js",
+      "import": "./debug/dist/debug.mjs",
+      "require": "./debug/dist/debug.js"
+    },
+    "./devtools": {
+      "types": "./devtools/src/index.d.ts",
+      "browser": "./devtools/dist/devtools.module.js",
+      "umd": "./devtools/dist/devtools.umd.js",
+      "import": "./devtools/dist/devtools.mjs",
+      "require": "./devtools/dist/devtools.js"
+    },
+    "./hooks": {
+      "types": "./hooks/src/index.d.ts",
+      "browser": "./hooks/dist/hooks.module.js",
+      "umd": "./hooks/dist/hooks.umd.js",
+      "import": "./hooks/dist/hooks.mjs",
+      "require": "./hooks/dist/hooks.js"
+    },
+    "./test-utils": {
+      "types": "./test-utils/src/index.d.ts",
+      "browser": "./test-utils/dist/testUtils.module.js",
+      "umd": "./test-utils/dist/testUtils.umd.js",
+      "import": "./test-utils/dist/testUtils.mjs",
+      "require": "./test-utils/dist/testUtils.js"
+    },
+    "./compat/test-utils": {
+      "types": "./test-utils/src/index.d.ts",
+      "browser": "./test-utils/dist/testUtils.module.js",
+      "umd": "./test-utils/dist/testUtils.umd.js",
+      "import": "./test-utils/dist/testUtils.mjs",
+      "require": "./test-utils/dist/testUtils.js"
+    },
+    "./jsx-runtime": {
+      "types": "./jsx-runtime/src/index.d.ts",
+      "browser": "./jsx-runtime/dist/jsxRuntime.module.js",
+      "umd": "./jsx-runtime/dist/jsxRuntime.umd.js",
+      "import": "./jsx-runtime/dist/jsxRuntime.mjs",
+      "require": "./jsx-runtime/dist/jsxRuntime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./jsx-runtime/src/index.d.ts",
+      "browser": "./jsx-runtime/dist/jsxRuntime.module.js",
+      "umd": "./jsx-runtime/dist/jsxRuntime.umd.js",
+      "import": "./jsx-runtime/dist/jsxRuntime.mjs",
+      "require": "./jsx-runtime/dist/jsxRuntime.js"
+    },
+    "./compat/client": {
+      "types": "./compat/client.d.ts",
+      "import": "./compat/client.mjs",
+      "require": "./compat/client.js"
+    },
+    "./compat/server": {
+      "browser": "./compat/server.browser.js",
+      "import": "./compat/server.mjs",
+      "require": "./compat/server.js"
+    },
+    "./compat/server.browser": {
+      "types": "./compat/server.d.ts",
+      "default": "./compat/server.browser.js"
+    },
+    "./compat/jsx-runtime": {
+      "types": "./jsx-runtime/src/index.d.ts",
+      "import": "./compat/jsx-runtime.mjs",
+      "require": "./compat/jsx-runtime.js"
+    },
+    "./compat/jsx-dev-runtime": {
+      "types": "./jsx-runtime/src/index.d.ts",
+      "import": "./compat/jsx-dev-runtime.mjs",
+      "require": "./compat/jsx-dev-runtime.js"
+    },
+    "./compat/scheduler": {
+      "import": "./compat/scheduler.mjs",
+      "require": "./compat/scheduler.js"
+    },
+    "./package.json": "./package.json",
+    "./compat/package.json": "./compat/package.json",
+    "./debug/package.json": "./debug/package.json",
+    "./devtools/package.json": "./devtools/package.json",
+    "./hooks/package.json": "./hooks/package.json",
+    "./test-utils/package.json": "./test-utils/package.json",
+    "./jsx-runtime/package.json": "./jsx-runtime/package.json"
+  },
+  "license": "MIT",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/preact"
+  },
+  "types": "src/index.d.ts",
+  "scripts": {
+    "prepare": "husky && run-s build",
+    "build": "npm-run-all --parallel 'build:*'",
+    "build:core": "microbundle build --raw --no-generateTypes -f cjs,esm,umd",
+    "build:core-min": "microbundle build --raw --no-generateTypes -f cjs,esm,umd,iife src/cjs.js -o dist/preact.min.js",
+    "build:debug": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd debug",
+    "build:devtools": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd devtools",
+    "build:hooks": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd hooks",
+    "build:test-utils": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd test-utils",
+    "build:compat": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd compat --globals 'preact/hooks=preactHooks'",
+    "build:jsx": "microbundle build --raw --no-generateTypes -f cjs,esm,umd --cwd jsx-runtime",
+    "postbuild": "node ./config/node-13-exports.js && node ./config/compat-entries.js",
+    "dev": "microbundle watch --raw --no-generateTypes --format cjs",
+    "dev:hooks": "microbundle watch --raw --no-generateTypes --format cjs --cwd hooks",
+    "dev:compat": "microbundle watch --raw --no-generateTypes --format cjs --cwd compat --globals 'preact/hooks=preactHooks'",
+    "test": "npm-run-all build lint test:unit",
+    "test:unit": "run-p test:mocha test:vitest:min test:ts",
+    "test:vitest": "cross-env COVERAGE=true vitest run",
+    "test:vitest:min": "cross-env MINIFY=true vitest run",
+    "test:vitest:watch": "vitest",
+    "test:ts": "run-p 'test:ts:*'",
+    "test:ts:core": "tsc -p test/ts/ && mocha --require \"@babel/register\" test/ts/**/*-test.js",
+    "test:ts:compat": "tsc -p compat/test/ts/",
+    "test:mocha": "mocha --recursive --require \"@babel/register\" test/shared test/node",
+    "test:mocha:watch": "npm run test:mocha -- --watch",
+    "lint": "run-s oxlint tsc",
+    "tsc": "tsc -p jsconfig-lint.json",
+    "oxlint": "oxlint -c oxlint.json src test/browser test/node test/shared debug compat hooks test-utils",
+    "format": "biome format --write .",
+    "format:check": "biome format ."
+  },
+  "nano-staged": {
+    "**/*.{js,jsx,mjs,cjs,ts,tsx,yml,json,html,md,css,scss}": [
+      "biome format --write --no-errors-on-unmatched"
+    ]
+  },
+  "files": [
+    "src",
+    "dist",
+    "compat/dist",
+    "compat/src",
+    "compat/client.d.ts",
+    "compat/client.js",
+    "compat/client.mjs",
+    "compat/server.browser.js",
+    "compat/server.js",
+    "compat/server.mjs",
+    "compat/scheduler.js",
+    "compat/scheduler.mjs",
+    "compat/test-utils.js",
+    "compat/test-utils.mjs",
+    "compat/jsx-runtime.js",
+    "compat/jsx-runtime.mjs",
+    "compat/jsx-dev-runtime.js",
+    "compat/jsx-dev-runtime.mjs",
+    "compat/package.json",
+    "debug/dist",
+    "debug/src",
+    "debug/package.json",
+    "devtools/dist",
+    "devtools/src",
+    "devtools/package.json",
+    "hooks/dist",
+    "hooks/src",
+    "hooks/package.json",
+    "jsx-runtime/dist",
+    "jsx-runtime/src",
+    "jsx-runtime/package.json",
+    "test-utils/src",
+    "test-utils/package.json",
+    "test-utils/dist"
+  ],
+  "keywords": [
+    "preact",
+    "react",
+    "ui",
+    "user interface",
+    "virtual dom",
+    "vdom",
+    "components",
+    "dom diff",
+    "front-end",
+    "framework"
+  ],
+  "authors": [
+    "The Preact Authors (https://github.com/preactjs/preact/contributors)"
+  ],
+  "repository": "preactjs/preact",
+  "bugs": "https://github.com/preactjs/preact/issues",
+  "homepage": "https://preactjs.com",
+  "devDependencies": {
+    "@actions/github": "^6.0.0",
+    "@actions/glob": "^0.5.0",
+    "@babel/core": "^7.26.0",
+    "@babel/plugin-transform-react-jsx": "^7.25.9",
+    "@babel/plugin-transform-react-jsx-source": "^7.25.9",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/register": "^7.25.9",
+    "@biomejs/biome": "^1.9.4",
+    "@types/chai": "^5.0.1",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.19.87",
+    "@types/sinon": "^17.0.3",
+    "@vitest/browser": "^3.2.1",
+    "@vitest/coverage-istanbul": "^3.2.1",
+    "babel-plugin-transform-rename-properties": "0.1.0",
+    "chai": "^5.2.0",
+    "coveralls": "^3.1.1",
+    "cross-env": "^7.0.3",
+    "errorstacks": "^2.4.1",
+    "esbuild": "^0.24.0",
+    "husky": "^9.1.7",
+    "kolorist": "^1.8.0",
+    "microbundle": "^0.15.1",
+    "mocha": "^11.0.0",
+    "npm-run-all2": "^7.0.0",
+    "oxlint": "^0.15.12",
+    "preact-render-to-string": "^6.5.0",
+    "prop-types": "^15.8.1",
+    "sade": "^1.8.1",
+    "sinon": "^19.0.2",
+    "sinon-chai": "^4.0.0",
+    "terser": "5.16.0",
+    "typescript": "5.1.6",
+    "undici": "^4.12.0",
+    "vite": "^6.2.0",
+    "vitest": "^3.2.1",
+    "webdriverio": "^9.15.0"
+  },
+  "volta": {
+    "node": "20.19.1"
+  }
+}

package/templates/static/node_modules/preact/src/cjs.js

@@ -0,0 +1,3 @@
+import * as preact from './index.js';
+if (typeof module < 'u') module.exports = preact;
+else self.preact = preact;

package/templates/static/node_modules/preact/src/clone-element.js

@@ -0,0 +1,48 @@
+import { assign, slice } from './util';
+import { createVNode } from './create-element';
+import { NULL, UNDEFINED } from './constants';
+
+/**
+ * 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/templates/static/node_modules/preact/src/component.js

@@ -0,0 +1,249 @@
+import { assign } from './util';
+import { diff, commitRoot } from './diff/index';
+import options from './options';
+import { Fragment } from './create-element';
+import { MODE_HYDRATE, NULL } from './constants';
+
+/**
+ * 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 BaseComponent(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
+ */
+BaseComponent.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._stateCallbacks.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
+ */
+BaseComponent.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](https://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 {ComponentChildren | void}
+ */
+BaseComponent.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._index + 1)
+			: NULL;
+	}
+
+	let sibling;
+	for (; childIndex < vnode._children.length; childIndex++) {
+		sibling = vnode._children[childIndex];
+
+		if (sibling != NULL && sibling._dom != NULL) {
+			// 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 oldVNode = component._vnode,
+		oldDom = oldVNode._dom,
+		commitQueue = [],
+		refQueue = [];
+
+	if (component._parentDom) {
+		const newVNode = assign({}, oldVNode);
+		newVNode._original = oldVNode._original + 1;
+		if (options.vnode) options.vnode(newVNode);
+
+		diff(
+			component._parentDom,
+			newVNode,
+			oldVNode,
+			component._globalContext,
+			component._parentDom.namespaceURI,
+			oldVNode._flags & MODE_HYDRATE ? [oldDom] : NULL,
+			commitQueue,
+			oldDom == NULL ? getDomSibling(oldVNode) : oldDom,
+			!!(oldVNode._flags & MODE_HYDRATE),
+			refQueue
+		);
+
+		newVNode._original = oldVNode._original;
+		newVNode._parent._children[newVNode._index] = newVNode;
+		commitRoot(commitQueue, newVNode, refQueue);
+		oldVNode._dom = oldVNode._parent = null;
+
+		if (newVNode._dom != oldDom) {
+			updateParentDomPointers(newVNode);
+		}
+	}
+}
+
+/**
+ * @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 = [];
+
+/*
+ * 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;
+
+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 || defer)(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,
+		l = 1;
+
+	// 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 (rerenderQueue.length) {
+		// Keep the rerender queue sorted by (depth, insertion order). The queue
+		// will initially be sorted on the first iteration only if it has more than 1 item.
+		//
+		// New items can be added to the queue e.g. when rerendering a provider, so we want to
+		// keep the order from top to bottom with those new items so we can handle them in a
+		// single pass
+		if (rerenderQueue.length > l) {
+			rerenderQueue.sort(depthSort);
+		}
+
+		c = rerenderQueue.shift();
+		l = rerenderQueue.length;
+
+		if (c._dirty) {
+			renderComponent(c);
+		}
+	}
+	process._rerenderCount = 0;
+}
+
+process._rerenderCount = 0;

package/templates/static/node_modules/preact/src/constants.js

@@ -0,0 +1,22 @@
+/** Normal hydration that attaches to a DOM tree but does not diff it. */
+export const MODE_HYDRATE = 1 << 5;
+/** Signifies this VNode suspended on the previous render */
+export const MODE_SUSPENDED = 1 << 7;
+/** Indicates that this node needs to be inserted while patching children */
+export const INSERT_VNODE = 1 << 2;
+/** Indicates a VNode has been matched with another VNode in the diff */
+export const MATCHED = 1 << 1;
+
+/** Reset all mode flags */
+export const RESET_MODE = ~(MODE_HYDRATE | MODE_SUSPENDED);
+
+export const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+export const XHTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+export const MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+
+export const NULL = null;
+export const UNDEFINED = undefined;
+export const EMPTY_OBJ = /** @type {any} */ ({});
+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/templates/static/node_modules/preact/src/create-context.js

@@ -0,0 +1,60 @@
+import { enqueueRender } from './component';
+import { NULL } from './constants';
+
+export let i = 0;
+
+export function createContext(defaultValue) {
+	function Context(props) {
+		if (!this.getChildContext) {
+			/** @type {Set<import('./internal').Component> | null} */
+			let subs = new Set();
+			let ctx = {};
+			ctx[Context._id] = this;
+
+			this.getChildContext = () => ctx;
+
+			this.componentWillUnmount = () => {
+				subs = NULL;
+			};
+
+			this.shouldComponentUpdate = function (_props) {
+				// @ts-expect-error even
+				if (this.props.value != _props.value) {
+					subs.forEach(c => {
+						c._force = true;
+						enqueueRender(c);
+					});
+				}
+			};
+
+			this.sub = c => {
+				subs.add(c);
+				let old = c.componentWillUnmount;
+				c.componentWillUnmount = () => {
+					if (subs) {
+						subs.delete(c);
+					}
+					if (old) old.call(c);
+				};
+			};
+		}
+
+		return props.children;
+	}
+
+	Context._id = '__cC' + i++;
+	Context._defaultValue = defaultValue;
+
+	/** @type {import('./internal').FunctionComponent} */
+	Context.Consumer = (props, contextValue) => {
+		return props.children(contextValue);
+	};
+
+	// we could also get rid of _contextRef entirely
+	Context.Provider =
+		Context._contextRef =
+		Context.Consumer.contextType =
+			Context;
+
+	return Context;
+}