@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@playcanvas/pcui/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "@playcanvas/pcui",
+  "version": "6.1.4",
+  "author": "PlayCanvas <support@playcanvas.com>",
+  "homepage": "https://playcanvas.com",
+  "description": "User interface component library for the web",
+  "keywords": [
+    "components",
+    "css",
+    "dom",
+    "html",
+    "javascript",
+    "pcui",
+    "playcanvas",
+    "react",
+    "sass",
+    "typescript",
+    "ui"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/module/src/index.mjs",
+  "module": "dist/module/src/index.mjs",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/module/src/index.mjs"
+    },
+    "./react": {
+      "types": "./react/types/index.d.ts",
+      "import": "./react/dist/module/src/index.mjs"
+    },
+    "./styles": {
+      "import": "./styles/dist/index.mjs"
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/playcanvas/pcui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/playcanvas/pcui.git"
+  },
+  "files": [
+    "dist",
+    "types",
+    "react/dist",
+    "react/types",
+    "react/package.json",
+    "styles"
+  ],
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "dependencies": {
+    "@playcanvas/observer": "^1.5.1"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "7.29.5",
+    "@babel/preset-react": "7.28.5",
+    "@babel/preset-typescript": "7.28.5",
+    "@playcanvas/eslint-config": "2.1.0",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@rollup/plugin-replace": "6.0.3",
+    "@rollup/plugin-typescript": "12.3.0",
+    "@storybook/addon-docs": "10.4.0",
+    "@storybook/addon-webpack5-compiler-swc": "4.0.3",
+    "@storybook/react-webpack5": "10.4.0",
+    "@types/estree": "1.0.9",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "@typescript-eslint/eslint-plugin": "8.59.3",
+    "@typescript-eslint/parser": "8.59.3",
+    "autoprefixer": "10.5.0",
+    "concurrently": "9.2.1",
+    "cross-env": "10.1.0",
+    "css-loader": "7.1.4",
+    "eslint": "9.39.4",
+    "eslint-import-resolver-typescript": "4.4.4",
+    "eslint-plugin-storybook": "10.4.0",
+    "global-jsdom": "28.0.0",
+    "globals": "17.6.0",
+    "jsdom": "28.1.0",
+    "playcanvas": "2.18.1",
+    "postcss": "8.5.14",
+    "prop-types": "15.8.1",
+    "publint": "0.3.21",
+    "rollup": "4.60.3",
+    "rollup-plugin-sass": "1.15.3",
+    "sass-loader": "16.0.8",
+    "scss-bundle": "3.1.2",
+    "serve": "14.2.6",
+    "storybook": "10.4.0",
+    "style-loader": "4.0.0",
+    "stylelint": "17.11.1",
+    "stylelint-config-standard-scss": "17.0.0",
+    "typedoc": "0.28.19",
+    "typedoc-plugin-mdn-links": "5.1.1",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1 || ^19.0.0",
+    "react-dom": "^18.3.1 || ^19.0.0"
+  },
+  "scripts": {
+    "build": "rollup -c && npm run bundle:styles && npm run build:types",
+    "build:es6": "rollup -c --environment target:es6",
+    "build:icons": "cd ./utils && node ./build-font-icons.mjs",
+    "build:react:es6": "rollup -c --environment target:react:es6",
+    "build:storybook": "cross-env ENVIRONMENT=production storybook build -o storybook",
+    "build:styles": "rollup -c --environment target:styles",
+    "build:types": "tsc --project ./tsconfig.json --declaration --emitDeclarationOnly --outDir types && tsc --project ./react/tsconfig.json --declaration --emitDeclarationOnly --outDir ./react/types",
+    "bundle:styles": "scss-bundle -e ./src/scss/pcui-theme-grey.scss -o ./dist/pcui-theme-grey.scss && scss-bundle -e ./src/scss/pcui-theme-green.scss -o ./dist/pcui-theme-green.scss",
+    "develop": "cross-env concurrently --kill-others \"npm run watch\" \"npm run serve\"",
+    "docs": "typedoc",
+    "lint": "npm run lint:js && npm run lint:styles",
+    "lint:js": "eslint src utils rollup.config.mjs eslint.config.mjs",
+    "lint:js:fix": "eslint src utils rollup.config.mjs eslint.config.mjs --fix",
+    "lint:styles": "stylelint src/**/*.scss",
+    "publint": "publint",
+    "serve": "serve",
+    "storybook": "storybook dev -p 9000",
+    "test": "node --test",
+    "watch": "rollup -c -w",
+    "watch:es6": "rollup -c -w --environment target:es6",
+    "watch:react:es6": "rollup -c -w --environment target:react:es6",
+    "watch:styles": "rollup -c -w --environment target:styles"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  }
+}

package/node_modules/@playcanvas/pcui/react/dist/module/node_modules/playcanvas/build/playcanvas/src/core/math/constants.mjs

@@ -0,0 +1,6 @@
+const CURVE_LINEAR = 0;
+const CURVE_SMOOTHSTEP = 1;
+const CURVE_SPLINE = 4;
+const CURVE_STEP = 5;
+
+export { CURVE_LINEAR, CURVE_SMOOTHSTEP, CURVE_SPLINE, CURVE_STEP };

package/node_modules/@playcanvas/pcui/react/dist/module/node_modules/playcanvas/build/playcanvas/src/core/math/curve-evaluator.mjs

@@ -0,0 +1,119 @@
+import { CURVE_STEP, CURVE_LINEAR, CURVE_SMOOTHSTEP, CURVE_SPLINE } from './constants.mjs';
+import { math } from './math.mjs';
+
+class CurveEvaluator {
+		evaluate(time, forceReset = false) {
+				if (forceReset || time < this._left || time >= this._right) {
+						this._reset(time);
+				}
+				let result;
+				const type = this._curve.type;
+				if (type === CURVE_STEP) {
+						result = this._p0;
+				} else {
+						const t = this._recip === 0 ? 0 : (time - this._left) * this._recip;
+						if (type === CURVE_LINEAR) {
+								result = math.lerp(this._p0, this._p1, t);
+						} else if (type === CURVE_SMOOTHSTEP) {
+								result = math.lerp(this._p0, this._p1, t * t * (3 - 2 * t));
+						} else {
+								result = this._evaluateHermite(this._p0, this._p1, this._m0, this._m1, t);
+						}
+				}
+				return result;
+		}
+		_reset(time) {
+				const keys = this._curve.keys;
+				const len = keys.length;
+				if (!len) {
+						this._left = -Infinity;
+						this._right = Infinity;
+						this._recip = 0;
+						this._p0 = this._p1 = this._m0 = this._m1 = 0;
+				} else {
+						if (time < keys[0][0]) {
+								this._left = -Infinity;
+								this._right = keys[0][0];
+								this._recip = 0;
+								this._p0 = this._p1 = keys[0][1];
+								this._m0 = this._m1 = 0;
+						} else if (time >= keys[len - 1][0]) {
+								this._left = keys[len - 1][0];
+								this._right = Infinity;
+								this._recip = 0;
+								this._p0 = this._p1 = keys[len - 1][1];
+								this._m0 = this._m1 = 0;
+						} else {
+								let index = 0;
+								while(time >= keys[index + 1][0]){
+										index++;
+								}
+								this._left = keys[index][0];
+								this._right = keys[index + 1][0];
+								const diff = 1.0 / (this._right - this._left);
+								this._recip = isFinite(diff) ? diff : 0;
+								this._p0 = keys[index][1];
+								this._p1 = keys[index + 1][1];
+								if (this._curve.type === CURVE_SPLINE) {
+										this._calcTangents(keys, index);
+								}
+						}
+				}
+		}
+		_calcTangents(keys, index) {
+				let a;
+				const b = keys[index];
+				const c = keys[index + 1];
+				let d;
+				if (index === 0) {
+						a = [
+								keys[0][0] + (keys[0][0] - keys[1][0]),
+								keys[0][1] + (keys[0][1] - keys[1][1])
+						];
+				} else {
+						a = keys[index - 1];
+				}
+				if (index === keys.length - 2) {
+						d = [
+								keys[index + 1][0] + (keys[index + 1][0] - keys[index][0]),
+								keys[index + 1][1] + (keys[index + 1][1] - keys[index][1])
+						];
+				} else {
+						d = keys[index + 2];
+				}
+				if (this._curve.type === CURVE_SPLINE) {
+						const s1_ = 2 * (c[0] - b[0]) / (c[0] - a[0]);
+						const s2_ = 2 * (c[0] - b[0]) / (d[0] - b[0]);
+						this._m0 = this._curve.tension * (isFinite(s1_) ? s1_ : 0) * (c[1] - a[1]);
+						this._m1 = this._curve.tension * (isFinite(s2_) ? s2_ : 0) * (d[1] - b[1]);
+				} else {
+						const s1 = (c[0] - b[0]) / (b[0] - a[0]);
+						const s2 = (c[0] - b[0]) / (d[0] - c[0]);
+						const a_ = b[1] + (a[1] - b[1]) * (isFinite(s1) ? s1 : 0);
+						const d_ = c[1] + (d[1] - c[1]) * (isFinite(s2) ? s2 : 0);
+						const tension = this._curve.tension;
+						this._m0 = tension * (c[1] - a_);
+						this._m1 = tension * (d_ - b[1]);
+				}
+		}
+		_evaluateHermite(p0, p1, m0, m1, t) {
+				const t2 = t * t;
+				const twot = t + t;
+				const omt = 1 - t;
+				const omt2 = omt * omt;
+				return p0 * ((1 + twot) * omt2) + m0 * (t * omt2) + p1 * (t2 * (3 - twot)) + m1 * (t2 * (t - 1));
+		}
+		constructor(curve, time = 0){
+				this._left = -Infinity;
+				this._right = Infinity;
+				this._recip = 0;
+				this._p0 = 0;
+				this._p1 = 0;
+				this._m0 = 0;
+				this._m1 = 0;
+				this._curve = curve;
+				this._reset(time);
+		}
+}
+
+export { CurveEvaluator };

package/node_modules/@playcanvas/pcui/react/dist/module/node_modules/playcanvas/build/playcanvas/src/core/math/curve-set.mjs

@@ -0,0 +1,82 @@
+import { CURVE_SMOOTHSTEP } from './constants.mjs';
+import { Curve } from './curve.mjs';
+import { CurveEvaluator } from './curve-evaluator.mjs';
+
+class CurveSet {
+		get length() {
+				return this.curves.length;
+		}
+		set type(value) {
+				this._type = value;
+				for(let i = 0; i < this.curves.length; i++){
+						this.curves[i].type = value;
+				}
+		}
+		get type() {
+				return this._type;
+		}
+		get(index) {
+				return this.curves[index];
+		}
+		value(time, result = []) {
+				const length = this.curves.length;
+				result.length = length;
+				for(let i = 0; i < length; i++){
+						result[i] = this.curves[i].value(time);
+				}
+				return result;
+		}
+		clone() {
+				const result = new this.constructor();
+				result.curves = [];
+				for(let i = 0; i < this.curves.length; i++){
+						result.curves.push(this.curves[i].clone());
+				}
+				result._type = this._type;
+				return result;
+		}
+		quantize(precision) {
+				precision = Math.max(precision, 2);
+				const numCurves = this.curves.length;
+				const values = new Float32Array(precision * numCurves);
+				const step = 1.0 / (precision - 1);
+				for(let c = 0; c < numCurves; c++){
+						const ev = new CurveEvaluator(this.curves[c]);
+						for(let i = 0; i < precision; i++){
+								values[i * numCurves + c] = ev.evaluate(step * i);
+						}
+				}
+				return values;
+		}
+		quantizeClamped(precision, min, max) {
+				const result = this.quantize(precision);
+				for(let i = 0; i < result.length; ++i){
+						result[i] = Math.min(max, Math.max(min, result[i]));
+				}
+				return result;
+		}
+		constructor(...args){
+				this.curves = [];
+				this._type = CURVE_SMOOTHSTEP;
+				if (args.length > 1) {
+						for(let i = 0; i < args.length; i++){
+								this.curves.push(new Curve(args[i]));
+						}
+				} else if (args.length === 0) {
+						this.curves.push(new Curve());
+				} else {
+						const arg = args[0];
+						if (typeof arg === 'number') {
+								for(let i = 0; i < arg; i++){
+										this.curves.push(new Curve());
+								}
+						} else {
+								for(let i = 0; i < arg.length; i++){
+										this.curves.push(new Curve(arg[i]));
+								}
+						}
+				}
+		}
+}
+
+export { CurveSet };

package/node_modules/@playcanvas/pcui/react/dist/module/node_modules/playcanvas/build/playcanvas/src/core/math/curve.mjs

@@ -0,0 +1,92 @@
+import { CURVE_SMOOTHSTEP } from './constants.mjs';
+import { CurveEvaluator } from './curve-evaluator.mjs';
+
+class Curve {
+		get length() {
+				return this.keys.length;
+		}
+		add(time, value) {
+				const keys = this.keys;
+				const len = keys.length;
+				let i = 0;
+				for(; i < len; i++){
+						if (keys[i][0] > time) {
+								break;
+						}
+				}
+				const key = [
+						time,
+						value
+				];
+				this.keys.splice(i, 0, key);
+				return key;
+		}
+		get(index) {
+				return this.keys[index];
+		}
+		sort() {
+				this.keys.sort((a, b)=>a[0] - b[0]);
+		}
+		value(time) {
+				return this._eval.evaluate(time, true);
+		}
+		closest(time) {
+				const keys = this.keys;
+				const length = keys.length;
+				let min = 2;
+				let result = null;
+				for(let i = 0; i < length; i++){
+						const diff = Math.abs(time - keys[i][0]);
+						if (min >= diff) {
+								min = diff;
+								result = keys[i];
+						} else {
+								break;
+						}
+				}
+				return result;
+		}
+		clone() {
+				const result = new this.constructor();
+				result.keys = this.keys.map((key)=>[
+								...key
+						]);
+				result.type = this.type;
+				result.tension = this.tension;
+				return result;
+		}
+		quantize(precision) {
+				precision = Math.max(precision, 2);
+				const values = new Float32Array(precision);
+				const step = 1.0 / (precision - 1);
+				values[0] = this._eval.evaluate(0, true);
+				for(let i = 1; i < precision; i++){
+						values[i] = this._eval.evaluate(step * i);
+				}
+				return values;
+		}
+		quantizeClamped(precision, min, max) {
+				const result = this.quantize(precision);
+				for(let i = 0; i < result.length; ++i){
+						result[i] = Math.min(max, Math.max(min, result[i]));
+				}
+				return result;
+		}
+		constructor(data){
+				this.keys = [];
+				this.type = CURVE_SMOOTHSTEP;
+				this.tension = 0.5;
+				this._eval = new CurveEvaluator(this);
+				if (data) {
+						for(let i = 0; i < data.length - 1; i += 2){
+								this.keys.push([
+										data[i],
+										data[i + 1]
+								]);
+						}
+				}
+				this.sort();
+		}
+}
+
+export { Curve };

package/node_modules/@playcanvas/pcui/react/dist/module/node_modules/playcanvas/build/playcanvas/src/core/math/math.mjs

@@ -0,0 +1,105 @@
+const math = {
+		DEG_TO_RAD: Math.PI / 180,
+		RAD_TO_DEG: 180 / Math.PI,
+		clamp (value, min, max) {
+				if (value >= max) return max;
+				if (value <= min) return min;
+				return value;
+		},
+		intToBytes24 (i) {
+				const r = i >> 16 & 0xff;
+				const g = i >> 8 & 0xff;
+				const b = i & 0xff;
+				return [
+						r,
+						g,
+						b
+				];
+		},
+		intToBytes32 (i) {
+				const r = i >> 24 & 0xff;
+				const g = i >> 16 & 0xff;
+				const b = i >> 8 & 0xff;
+				const a = i & 0xff;
+				return [
+						r,
+						g,
+						b,
+						a
+				];
+		},
+		bytesToInt24 (r, g, b) {
+				if (r.length) {
+						b = r[2];
+						g = r[1];
+						r = r[0];
+				}
+				return r << 16 | g << 8 | b;
+		},
+		bytesToInt32 (r, g, b, a) {
+				if (r.length) {
+						a = r[3];
+						b = r[2];
+						g = r[1];
+						r = r[0];
+				}
+				return (r << 24 | g << 16 | b << 8 | a) >>> 0;
+		},
+		lerp (a, b, alpha) {
+				return a + (b - a) * math.clamp(alpha, 0, 1);
+		},
+		lerpAngle (a, b, alpha) {
+				if (b - a > 180) {
+						b -= 360;
+				}
+				if (b - a < -180) {
+						b += 360;
+				}
+				return math.lerp(a, b, math.clamp(alpha, 0, 1));
+		},
+		powerOfTwo (x) {
+				return x !== 0 && !(x & x - 1);
+		},
+		nextPowerOfTwo (val) {
+				val--;
+				val |= val >> 1;
+				val |= val >> 2;
+				val |= val >> 4;
+				val |= val >> 8;
+				val |= val >> 16;
+				val++;
+				return val;
+		},
+		nearestPowerOfTwo (val) {
+				return Math.pow(2, Math.round(Math.log2(val)));
+		},
+		random (min, max) {
+				const diff = max - min;
+				return Math.random() * diff + min;
+		},
+		smoothstep (min, max, x) {
+				if (x <= min) return 0;
+				if (x >= max) return 1;
+				x = (x - min) / (max - min);
+				return x * x * (3 - 2 * x);
+		},
+		smootherstep (min, max, x) {
+				if (x <= min) return 0;
+				if (x >= max) return 1;
+				x = (x - min) / (max - min);
+				return x * x * x * (x * (x * 6 - 15) + 10);
+		},
+		roundUp (numToRound, multiple) {
+				if (multiple === 0) {
+						return numToRound;
+				}
+				return Math.ceil(numToRound / multiple) * multiple;
+		},
+		between (num, a, b, inclusive) {
+				const min = Math.min(a, b);
+				const max = Math.max(a, b);
+				return inclusive ? num >= min && num <= max : num > min && num < max;
+		}
+};
+
+export { math };

package/node_modules/@playcanvas/pcui/react/dist/module/src/Math/color-value.mjs

@@ -0,0 +1,77 @@
+function _rgb2hsv(rgb) {
+    const r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255;
+    let h, s;
+    const v = Math.max(r, g, b);
+    const diff = v - Math.min(r, g, b);
+    const diffc = (c) => (v - c) / 6 / diff + 1 / 2;
+    if (diff === 0) {
+        h = s = 0;
+        return [h, s, v];
+    }
+    s = diff / v;
+    const rr = diffc(r);
+    const gg = diffc(g);
+    const bb = diffc(b);
+    if (r === v) {
+        h = bb - gg;
+    }
+    else if (g === v) {
+        h = (1 / 3) + rr - bb;
+    }
+    else if (b === v) {
+        h = (2 / 3) + gg - rr;
+    }
+    if (h < 0) {
+        h += 1;
+    }
+    else if (h > 1) {
+        h -= 1;
+    }
+    return [h, s, v];
+}
+function _hsv2rgb(hsv) {
+    const h = hsv[0];
+    const s = hsv[1];
+    const v = hsv[2];
+    let r, g, b;
+    const i = Math.floor(h * 6);
+    const f = h * 6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - f * s);
+    const t = v * (1 - (1 - f) * s);
+    switch (i % 6) {
+        case 0:
+            r = v;
+            g = t;
+            b = p;
+            break;
+        case 1:
+            r = q;
+            g = v;
+            b = p;
+            break;
+        case 2:
+            r = p;
+            g = v;
+            b = t;
+            break;
+        case 3:
+            r = p;
+            g = q;
+            b = v;
+            break;
+        case 4:
+            r = t;
+            g = p;
+            b = v;
+            break;
+        case 5:
+            r = v;
+            g = p;
+            b = q;
+            break;
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+}
+
+export { _hsv2rgb, _rgb2hsv };