tweaks 0.1.0

package/tweaks.js

@@ -0,0 +1,184 @@
+import { typeRegistry, syncedTweaks, sortedKeys, saveState, syncState, nextOrder } from './state.js';
+import { GUI } from './gui.js';
+export { GUI };
+
+/**
+ * @import {TweakRegister, StateProp} from './state.js'
+ */
+
+/** @type {Map<string, TweakGroup>} */
+const groups = new Map();
+
+/**
+ * @typedef {Object} TweakGroupMethods - Built-in type methods, added dynamically by registerType
+ * @property {(key: string, defaultValue?: number, min?: number, max?: number, step?: number) => number} Float
+ * @property {(key: string, defaultValue?: number, min?: number, max?: number) => number} Int
+ * @property {(key: string, defaultValue?: string) => string} Str
+ * @property {(key: string, defaultValue?: boolean) => boolean} Bool
+ * @property {(key: string, defaultValue?: string) => string} Color
+ */
+
+/**
+ * @typedef {TweakGroupBase & TweakGroupMethods & {[key: string]: any}} TweakGroup
+ */
+
+/**
+ * @param {TweakGroup} tweakGroup
+ * @param {string} key
+ * @param {TweakRegister} params
+ */
+function register(tweakGroup, key, params) {
+  const { type, defaultValue, n1, n2, n3, n4, n5, n6, n7 } = params;
+  const nameSpace = tweakGroup.nameSpace;
+  // Add getters / setters so group.key reads/writes nameSpace[key].value
+  if (!(key in tweakGroup)) {
+    Object.defineProperty(tweakGroup, key, {
+      get() { return this.nameSpace[key].value; },
+      set(v) {
+        this.nameSpace[key].value = v;
+        this.dirty = true;
+      },
+    });
+  }
+  let prop = nameSpace[key];
+  if (!prop) {
+    nameSpace[key] = {
+      type,
+      labelKey: `value::"${key}"`,
+      value: defaultValue,
+      default: defaultValue,
+      saved: defaultValue,
+      used: true,
+      order: nextOrder(),
+      n1,
+      n2,
+      n3,
+      n4,
+      n5,
+      n6,
+      n7,
+    }
+    tweakGroup.keys.push(key);
+    tweakGroup.dirty = true;
+    saveState();
+    return defaultValue;
+  }
+  prop.used = true;
+  const newOrder = nextOrder();
+  if (prop.order !== newOrder) {
+    prop.order = newOrder;
+    tweakGroup.dirty = true;
+  }
+  if (prop.type !== type) {
+    prop.type = type;
+    prop.value = defaultValue;
+    prop.saved = defaultValue;
+    prop.default = defaultValue;
+    saveState();
+    return defaultValue;
+  }
+  if (defaultValue !== prop.default) {
+    prop.value = defaultValue;
+    prop.default = defaultValue;
+    prop.saved = defaultValue;
+    saveState();
+  }
+  if (prop.n1 !== n1) prop.n1 = n1;
+  if (prop.n2 !== n2) prop.n2 = n2;
+  if (prop.n3 !== n3) prop.n3 = n3;
+  if (prop.n4 !== n4) prop.n4 = n4;
+  if (prop.n5 !== n5) prop.n5 = n5;
+  if (prop.n6 !== n6) prop.n6 = n6;
+  if (prop.n7 !== n7) prop.n7 = n7;
+  return prop.value;
+}
+
+class TweakGroupBase {
+  /**
+   * @param {string} stateName
+   * @param {Record<string, StateProp>} nameSpace
+   * @param {string[]} keys
+   */
+  constructor(stateName, nameSpace, keys) {
+    this.stateName = stateName;
+    this.nameSpace = nameSpace;
+    this.keys = keys;
+    this.dirty = false;
+    this.isTweakGroup = true;
+    this.changed = false;
+  }
+  /** Register a pre-built type descriptor, e.g. group.add('x', Float(0, 0, 100))
+   * @param {string} key
+   * @param {TweakRegister} params
+   */
+  add(key, params) {
+    return register(/** @type {TweakGroup} */(/** @type {any} */(this)), key, params);
+  }
+}
+
+/** @param {string} stateName */
+function createNamespace(stateName) {
+  if (!syncedTweaks[stateName]) syncedTweaks[stateName] = {};
+  if (!sortedKeys[stateName]) sortedKeys[stateName] = [];
+  return /** @type {TweakGroup} */(new TweakGroupBase(stateName, syncedTweaks[stateName], sortedKeys[stateName]));
+}
+
+export const TWEAKS = {
+  /**
+   * @param {string} name
+   * @param {Record<string, TweakRegister>} [schema]
+   */
+  group(name, schema) {
+    let group = groups.get(name);
+    if (!group) {
+      group = createNamespace(name);
+      groups.set(name, group);
+    }
+    if (schema) {
+      for (const key in schema) {
+        register(group, key, schema[key]);
+      }
+    }
+    return group;
+  },
+  /**
+   * @param {string} typeName
+   * @param {any} typeDefault
+   * @param {(prop: StateProp, labelKey: string) => boolean} [constructorFn]
+   * @return {(...args: any[]) => TweakRegister}
+   */
+  registerType(typeName, typeDefault, constructorFn) {
+    /** @type {(...args: any[]) => TweakRegister} */
+    const paramsFactory = (defaultValue = typeDefault, ...ns) => ({
+      type: typeName, defaultValue, n1: ns[0], n2: ns[1], n3: ns[2], n4: ns[3], n5: ns[4], n6: ns[5], n7: ns[6]
+    });
+    typeRegistry.set(typeName, { params: paramsFactory, constructor: constructorFn || (() => false) });
+    /** @type {any} */ (TweakGroupBase.prototype)[typeName] =
+    /** @this {TweakGroup} @param {string} key @param {...any} args */
+    function(key, ...args) {
+      // Fast getter: no extra args and key already exists
+      if (args.length === 0 && this.nameSpace[key]) {
+        const prop = this.nameSpace[key];
+        prop.used = true;
+        const newOrder = nextOrder();
+        if (prop.order !== newOrder) {
+          prop.order = newOrder;
+          this.dirty = true;
+        }
+        return prop.value;
+      }
+      return register(this, key, paramsFactory(...args));
+    };
+    return paramsFactory;
+  },
+  sync: syncState,
+  save: saveState,
+}
+
+// Register built-in tweak types
+
+export const Float = TWEAKS.registerType('Float', 0, (prop, labelKey) => GUI.Number(prop, labelKey, prop.n1, prop.n2, prop.n3));
+export const Int = TWEAKS.registerType('Int', 0, (prop, labelKey) => GUI.Number(prop, labelKey, prop.n1, prop.n2, 1));
+export const Str = TWEAKS.registerType('Str', '', (prop, labelKey) => GUI.Text(prop, labelKey));
+export const Bool = TWEAKS.registerType('Bool', false, (prop, labelKey) => GUI.Checkbox(prop, labelKey));
+export const Color = TWEAKS.registerType('Color', 'rgb(0, 0, 0)', (prop, labelKey) => GUI.Color(prop, labelKey));