@prtcl/plonk 1.0.1-beta.0 → 1.0.1-beta.1

package/dist/index.cjs

@@ -0,0 +1,680 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Drunk: () => Drunk,
+  Env: () => Env,
+  Frames: () => Frames,
+  MS_IN_HOUR: () => MS_IN_HOUR,
+  MS_IN_MINUTE: () => MS_IN_MINUTE,
+  MS_IN_SECOND: () => MS_IN_SECOND,
+  Metro: () => Metro,
+  Rand: () => Rand,
+  SINE_PERIOD: () => SINE_PERIOD,
+  SIXTY_FPS: () => SIXTY_FPS,
+  Scale: () => Scale,
+  Sine: () => Sine,
+  TimeFormat: () => TimeFormat,
+  clamp: () => clamp,
+  expo: () => expo,
+  flip: () => flip,
+  ms: () => ms,
+  now: () => now
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/clamp.ts
+function clamp(n, min, max) {
+  let a = 0;
+  let b = 1;
+  if (typeof min === "number") {
+    if (typeof max === "number") {
+      a = min;
+      b = max;
+    } else {
+      a = 0;
+      b = min;
+    }
+  }
+  return Math.min(Math.max(n, a), b);
+}
+
+// src/math/Rand.ts
+var parseOptions = (opts) => {
+  return {
+    min: 0,
+    max: 1,
+    ...opts
+  };
+};
+var Rand = class _Rand {
+  constructor(opts) {
+    __publicField(this, "state");
+    const { min, max } = parseOptions(opts);
+    this.state = { max, min, value: void 0 };
+    this.next();
+  }
+  static rand(opts) {
+    return new _Rand(opts).value();
+  }
+  setRange(partialOpts) {
+    const { min, max } = {
+      ...this.state,
+      ...partialOpts
+    };
+    this.state = {
+      ...this.state,
+      max,
+      min,
+      value: clamp(this.state.value, min, max)
+    };
+  }
+  value() {
+    return this.state.value;
+  }
+  next() {
+    const { min, max } = this.state;
+    const updates = Math.random() * (max - min) + min;
+    this.state.value = updates;
+    return updates;
+  }
+};
+
+// src/math/Drunk.ts
+var DEFAULT_DRUNK_STEP = 0.1;
+var parseStepSize = (step) => typeof step !== "undefined" ? clamp(step, 0, 1) : DEFAULT_DRUNK_STEP;
+var parseOptions2 = (opts) => {
+  const { step, ...restOpts } = opts || {};
+  const parsedStepSize = parseStepSize(step);
+  return {
+    max: 1,
+    min: 0,
+    startsAt: void 0,
+    step: parsedStepSize,
+    ...restOpts
+  };
+};
+var Drunk = class {
+  constructor(opts) {
+    __publicField(this, "state");
+    __publicField(this, "_initialValue");
+    __publicField(this, "_step");
+    const { min, max, step, startsAt } = parseOptions2(opts);
+    this._initialValue = new Rand({ min, max });
+    this._step = new Rand({ min: -1, max: 1 });
+    const initialValue = typeof startsAt !== "undefined" ? startsAt : this._initialValue.value();
+    this.state = {
+      initialValue,
+      max,
+      min,
+      step,
+      value: initialValue
+    };
+  }
+  setRange(partialOpts) {
+    const { max, min } = {
+      min: this.state.min,
+      max: this.state.max,
+      ...partialOpts
+    };
+    this._initialValue.setRange({ min, max });
+    this.state = {
+      ...this.state,
+      ...min !== this.state.min || max !== this.state.max ? {
+        initialValue: clamp(this._initialValue.value(), min, max),
+        max,
+        min,
+        value: clamp(this.state.value, min, max)
+      } : {
+        max,
+        min
+      }
+    };
+  }
+  setStepSize(partialOpts) {
+    const step = parseStepSize(partialOpts.step);
+    this.state = {
+      ...this.state,
+      step
+    };
+  }
+  reset(opts) {
+    const { min, max, startsAt, step } = parseOptions2(opts);
+    this.setRange({ min, max });
+    this.setStepSize({ step });
+    const initialValue = typeof startsAt !== "undefined" ? startsAt : this._initialValue.next();
+    this.state = {
+      ...this.state,
+      initialValue,
+      value: initialValue
+    };
+  }
+  value() {
+    return this.state.value;
+  }
+  next() {
+    const { min, max, step, value } = this.state;
+    const updates = clamp(value + max * this._step.next() * step, min, max);
+    this.state.value = updates;
+    return updates;
+  }
+};
+
+// src/utils/now.ts
+var internal;
+if (typeof performance !== "undefined" && "now" in performance) {
+  internal = () => {
+    return performance.now();
+  };
+} else if (typeof process === "object" && // eslint-disable-next-line @typescript-eslint/no-base-to-string
+process.toString() === "[object process]") {
+  const timestamp = () => {
+    const hr = process.hrtime();
+    return hr[0] * 1e9 + hr[1];
+  };
+  const initial = timestamp();
+  internal = () => {
+    return (timestamp() - initial) / 1e6;
+  };
+} else {
+  const initial = Date.now();
+  internal = () => {
+    return Date.now() - initial;
+  };
+}
+function now() {
+  return internal();
+}
+
+// src/math/Scale.ts
+var parseOptions3 = (opts) => {
+  const { from, to } = {
+    ...opts,
+    from: {
+      min: 0,
+      max: 1,
+      ...opts?.from
+    },
+    to: {
+      min: 0,
+      max: 1,
+      ...opts?.to
+    }
+  };
+  return {
+    from,
+    to
+  };
+};
+var updateStateFromOptions = (opts, prevState) => {
+  const { from, to } = opts;
+  const updatedTo = {
+    ...prevState.to,
+    ...to
+  };
+  return {
+    ...prevState,
+    from: {
+      ...prevState.from,
+      ...from
+    },
+    to: updatedTo,
+    value: clamp(prevState.value, updatedTo.min, updatedTo.max)
+  };
+};
+var Scale = class _Scale {
+  constructor(opts) {
+    __publicField(this, "state");
+    const { from, to } = parseOptions3(opts);
+    this.state = { from, to, value: void 0 };
+  }
+  static scale(n, opts) {
+    return new _Scale(opts).scale(n);
+  }
+  setRanges(opts) {
+    this.state = updateStateFromOptions(opts, this.state);
+  }
+  reset(opts) {
+    const { from, to } = parseOptions3(opts);
+    this.state = { from, to, value: void 0 };
+  }
+  value() {
+    return this.state.value;
+  }
+  scale(n) {
+    const { from, to } = this.state;
+    const updates = to.min + (clamp(n, from.min, from.max) - from.min) * (to.max - to.min) / (from.max - from.min);
+    this.state.value = updates;
+    return updates;
+  }
+};
+
+// src/math/Env.ts
+var parseOptions4 = (opts) => {
+  return {
+    from: 0,
+    to: 1,
+    ...opts
+  };
+};
+var getInitialState = ({ from, to, duration }) => {
+  return {
+    duration,
+    from,
+    prev: now(),
+    to,
+    totalElapsed: 0,
+    value: from
+  };
+};
+var updateStateFromOptions2 = (opts, prevState) => {
+  const { from, to, duration } = {
+    ...prevState,
+    ...opts
+  };
+  return {
+    ...prevState,
+    duration,
+    from,
+    to,
+    totalElapsed: 0
+  };
+};
+var Env = class {
+  constructor(opts) {
+    __publicField(this, "state");
+    __publicField(this, "_interpolator");
+    const { from, to, duration } = parseOptions4(opts);
+    this.state = getInitialState({ from, to, duration });
+    this._interpolator = new Scale({
+      from: {
+        min: 0,
+        max: duration
+      },
+      to: {
+        min: from,
+        max: to
+      }
+    });
+  }
+  setDuration(duration) {
+    const { to, totalElapsed } = this.state;
+    this.state = {
+      ...this.state,
+      ...duration <= totalElapsed ? {
+        duration,
+        value: to
+      } : { duration }
+    };
+  }
+  reset(opts) {
+    const updates = updateStateFromOptions2(opts, this.state);
+    this.state = {
+      ...updates,
+      prev: now(),
+      value: updates.from
+    };
+    this._interpolator.setRanges({
+      from: {
+        min: 0,
+        max: updates.duration
+      },
+      to: {
+        min: updates.from,
+        max: updates.to
+      }
+    });
+  }
+  done() {
+    return this.state.duration <= this.state.totalElapsed;
+  }
+  value() {
+    const { to, value } = this.state;
+    if (this.done()) {
+      return to;
+    }
+    return value;
+  }
+  next() {
+    if (this.done()) {
+      return this.value();
+    }
+    const { prev, totalElapsed: prevTotalElapsed } = this.state;
+    const curr = now();
+    const tickInterval = curr - prev;
+    const totalElapsed = prevTotalElapsed + tickInterval;
+    const updates = this._interpolator.scale(totalElapsed);
+    this.state.prev = curr;
+    this.state.totalElapsed = totalElapsed;
+    this.state.value = updates;
+    return updates;
+  }
+};
+
+// src/math/Sine.ts
+var SINE_PERIOD = Math.PI * 2 - 1e-4;
+var getInitialState2 = (duration) => ({
+  cycle: 0,
+  duration,
+  prev: now(),
+  totalElapsed: 0,
+  value: 0
+});
+var Sine = class {
+  constructor(opts) {
+    __publicField(this, "state");
+    __publicField(this, "_interpolator");
+    const { duration } = opts;
+    this._interpolator = new Scale({
+      from: {
+        min: 0,
+        max: duration
+      },
+      to: {
+        min: 0,
+        max: SINE_PERIOD
+      }
+    });
+    this.state = getInitialState2(duration);
+  }
+  setDuration(duration) {
+    this.state = {
+      ...this.state,
+      duration
+    };
+  }
+  reset(opts) {
+    const { duration } = {
+      ...this.state,
+      ...opts
+    };
+    this.state = getInitialState2(duration);
+  }
+  value() {
+    return this.state.value;
+  }
+  next() {
+    const {
+      cycle,
+      duration,
+      prev,
+      totalElapsed: prevTotalElapsed
+    } = this.state;
+    const curr = now();
+    const tickInterval = curr - prev;
+    const totalElapsed = prevTotalElapsed + tickInterval;
+    const updates = clamp(
+      Math.sin(this._interpolator.scale(totalElapsed)),
+      -1,
+      1
+    );
+    if (cycle >= duration) {
+      this.state.cycle = 0;
+    } else {
+      this.state.cycle = cycle + tickInterval;
+    }
+    this.state.prev = curr;
+    this.state.totalElapsed = totalElapsed;
+    this.state.value = updates;
+    return updates;
+  }
+};
+
+// src/constants.ts
+var SIXTY_FPS = 1e3 / 60;
+var MS_IN_SECOND = 1e3;
+var MS_IN_MINUTE = 60 * MS_IN_SECOND;
+var MS_IN_HOUR = MS_IN_MINUTE * 60;
+
+// src/utils/ms.ts
+var TimeFormat = /* @__PURE__ */ ((TimeFormat2) => {
+  TimeFormat2["FPS"] = "fps";
+  TimeFormat2["HOURS"] = "h";
+  TimeFormat2["HZ"] = "hz";
+  TimeFormat2["MILLISECONDS"] = "ms";
+  TimeFormat2["MINUTES"] = "m";
+  TimeFormat2["SECONDS"] = "s";
+  return TimeFormat2;
+})(TimeFormat || {});
+var FORMAT_IDENTIFIERS = [
+  "fps" /* FPS */,
+  "h" /* HOURS */,
+  "hz" /* HZ */,
+  "ms" /* MILLISECONDS */,
+  "m" /* MINUTES */,
+  "s" /* SECONDS */
+].sort((a, b) => b.length - a.length);
+var FORMATTERS = /* @__PURE__ */ new Map([
+  ["fps" /* FPS */, (val) => MS_IN_SECOND / val],
+  ["h" /* HOURS */, (val) => val * MS_IN_HOUR],
+  ["hz" /* HZ */, (val) => 1 / val * MS_IN_SECOND],
+  ["ms" /* MILLISECONDS */, (val) => val],
+  ["m" /* MINUTES */, (val) => val * MS_IN_MINUTE],
+  ["s" /* SECONDS */, (val) => val * MS_IN_SECOND]
+]);
+var sanitizeStringVal = (val) => val.toLocaleLowerCase().trim();
+var parseStringValAndFormat = (val) => {
+  for (let i = 0; i < FORMAT_IDENTIFIERS.length; i += 1) {
+    const format = FORMAT_IDENTIFIERS[i];
+    if (val.includes(format)) {
+      const value = Number(val.replace(" ", "").replace(format, ""));
+      return {
+        format,
+        value
+      };
+    }
+  }
+  return {
+    format: void 0,
+    value: void 0
+  };
+};
+function ms(val, format = "ms" /* MILLISECONDS */) {
+  let parsedValue;
+  let parsedFormat = format;
+  if (val === null || typeof val === "undefined") {
+    return void 0;
+  }
+  if (typeof val === "string") {
+    const parsed = parseStringValAndFormat(sanitizeStringVal(val));
+    if (typeof parsed.value !== "undefined") {
+      parsedValue = parsed.value;
+    }
+    if (parsed.format) {
+      parsedFormat = parsed.format;
+    }
+  } else {
+    parsedValue = val;
+  }
+  if (Number.isNaN(val)) {
+    return void 0;
+  }
+  const formatter = FORMATTERS.get(parsedFormat);
+  if (!formatter) {
+    return void 0;
+  }
+  return formatter(parsedValue);
+}
+
+// src/timers/Metro.ts
+var getInitialState3 = (initialTime) => {
+  return {
+    initialTime,
+    isRunning: false,
+    iterations: -1,
+    prev: 0,
+    tickInterval: 0,
+    time: initialTime,
+    totalElapsed: 0
+  };
+};
+var processTimerState = (state) => {
+  const { time, prev, totalElapsed, iterations } = state;
+  const curr = now();
+  if (iterations === -1) {
+    return {
+      ...state,
+      prev: curr,
+      iterations: 0
+    };
+  }
+  const tickInterval = curr - prev;
+  if (tickInterval <= time) {
+    return null;
+  }
+  return {
+    ...state,
+    iterations: iterations + 1,
+    prev: curr,
+    tickInterval,
+    totalElapsed: totalElapsed + tickInterval
+  };
+};
+var parseOptions5 = (opts) => {
+  return {
+    time: SIXTY_FPS,
+    ...opts
+  };
+};
+var Metro = class {
+  constructor(callback, opts) {
+    __publicField(this, "state");
+    __publicField(this, "_listeners");
+    __publicField(this, "_timerId");
+    __publicField(this, "stop", () => {
+      const { totalElapsed } = this.state;
+      this.reset();
+      this.clearAsyncHandler();
+      return totalElapsed;
+    });
+    __publicField(this, "reset", () => {
+      const { initialTime } = this.state;
+      this.state = getInitialState3(initialTime);
+    });
+    __publicField(this, "setTime", (updatedTime = this.state.time) => {
+      const time = Math.max(updatedTime, 0);
+      this.state = {
+        ...this.state,
+        time,
+        initialTime: time
+      };
+    });
+    __publicField(this, "run", () => {
+      if (this.state.isRunning) {
+        this.stop();
+      }
+      this.state = {
+        ...this.state,
+        isRunning: true,
+        prev: now()
+      };
+      const tick = () => {
+        const updates = processTimerState(this.state);
+        if (updates) {
+          this.state = updates;
+          this._listeners.forEach((listener) => {
+            listener(this);
+          });
+        }
+        if (this.state.isRunning) {
+          this.asyncHandler(tick);
+        }
+      };
+      tick();
+    });
+    const { time } = parseOptions5(opts);
+    this.state = getInitialState3(time);
+    this._listeners = [callback];
+  }
+  asyncHandler(callback) {
+    this._timerId = setTimeout(callback, SIXTY_FPS);
+  }
+  clearAsyncHandler() {
+    clearTimeout(this._timerId);
+  }
+};
+
+// src/timers/Frames.ts
+var DEFAULT_FPS = 60;
+var parseOptions6 = (opts) => {
+  const { fps } = {
+    fps: DEFAULT_FPS,
+    ...opts
+  };
+  return {
+    time: ms(fps, "fps" /* FPS */)
+  };
+};
+var Frames = class extends Metro {
+  constructor(callback, opts) {
+    super(callback, parseOptions6(opts));
+    __publicField(this, "setFPS", (fps = DEFAULT_FPS) => {
+      this.setTime(ms(fps, "fps" /* FPS */));
+    });
+  }
+  asyncHandler(callback) {
+    if (typeof window === "undefined") {
+      super.asyncHandler(callback);
+    } else {
+      this._timerId = requestAnimationFrame(callback);
+    }
+  }
+  clearAsyncHandler() {
+    if (typeof window === "undefined") {
+      super.clearAsyncHandler();
+    } else {
+      cancelAnimationFrame(this._timerId);
+    }
+  }
+};
+
+// src/utils/expo.ts
+function expo(n) {
+  return Math.pow(clamp(n, 0, 1), Math.E);
+}
+
+// src/utils/flip.ts
+function flip(n) {
+  return n * -1;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Drunk,
+  Env,
+  Frames,
+  MS_IN_HOUR,
+  MS_IN_MINUTE,
+  MS_IN_SECOND,
+  Metro,
+  Rand,
+  SINE_PERIOD,
+  SIXTY_FPS,
+  Scale,
+  Sine,
+  TimeFormat,
+  clamp,
+  expo,
+  flip,
+  ms,
+  now
+});
+//# sourceMappingURL=index.cjs.map