@jyiro/ascii-script 0.1.0

package/dist/ascii-art-DCOQt4Se.js

@@ -0,0 +1,285 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _minScale, _maxScale, _speed, _easingFn, _amplitude, _frequency, _speed2, _easingFn2, _speed3, _spread, _saturation, _lightness, _baseColor, _variations, _speed4, _mode, _ColorGradientEffect_instances, hexToHSL_fn, getVariation_fn, _rotateX, _rotateY, _rotateZ, _perspective, _speed5;
+import { B as BaseEffect } from "./text-CKJIlRsq.js";
+const easing = {
+  linear: (t) => t,
+  easeInQuad: (t) => t * t,
+  easeOutQuad: (t) => t * (2 - t),
+  easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => --t * t * t + 1,
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1
+};
+class PulseEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _minScale, 0.95);
+    __privateAdd(this, _maxScale, 1.05);
+    __privateAdd(this, _speed, 2e-3);
+    __privateAdd(this, _easingFn, easing.easeInOutQuad);
+    __privateSet(this, _minScale, config.minScale || 0.95);
+    __privateSet(this, _maxScale, config.maxScale || 1.05);
+    __privateSet(this, _speed, config.speed || 2e-3);
+    __privateSet(this, _easingFn, easing[config.easing] || easing.easeInOutQuad);
+  }
+  render(text, elapsed, context = {}) {
+    const element = context.element;
+    if (!element) return text;
+    const time = elapsed * __privateGet(this, _speed);
+    const pulse2 = (Math.sin(time) + 1) / 2;
+    const scale = __privateGet(this, _minScale) + (__privateGet(this, _maxScale) - __privateGet(this, _minScale)) * pulse2;
+    element.style.transform = `scale(${scale})`;
+    element.style.transformOrigin = "center";
+    return text;
+  }
+}
+_minScale = new WeakMap();
+_maxScale = new WeakMap();
+_speed = new WeakMap();
+_easingFn = new WeakMap();
+const pulse = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PulseEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class WaveEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _amplitude, 3);
+    __privateAdd(this, _frequency, 0.8);
+    __privateAdd(this, _speed2, 2e-3);
+    __privateAdd(this, _easingFn2, easing.linear);
+    __privateSet(this, _amplitude, config.amplitude || 3);
+    __privateSet(this, _frequency, config.frequency || 0.8);
+    __privateSet(this, _speed2, config.speed || 2e-3);
+    __privateSet(this, _easingFn2, easing[config.easing] || easing.linear);
+  }
+  render(text, elapsed, context = {}) {
+    const lines = text.split("\n");
+    const time = elapsed * __privateGet(this, _speed2);
+    const waved = lines.map((line, i) => {
+      const offset = Math.sin(i * __privateGet(this, _frequency) + time) * __privateGet(this, _amplitude);
+      const charOffset = Math.round(offset);
+      if (charOffset > 0) {
+        return " ".repeat(charOffset) + line;
+      } else if (charOffset < 0) {
+        const absOffset = Math.abs(charOffset);
+        const trimmed = line.replace(/^ {1,}/, (spaces) => {
+          const trimAmount = Math.min(spaces.length, absOffset);
+          return spaces.slice(trimAmount);
+        });
+        return trimmed;
+      }
+      return line;
+    });
+    return waved.join("\n");
+  }
+}
+_amplitude = new WeakMap();
+_frequency = new WeakMap();
+_speed2 = new WeakMap();
+_easingFn2 = new WeakMap();
+const wave = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WaveEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class ColorCycleEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _speed3, 1e-3);
+    __privateAdd(this, _spread, 10);
+    __privateAdd(this, _saturation, 70);
+    __privateAdd(this, _lightness, 50);
+    __privateSet(this, _speed3, config.speed || 1e-3);
+    __privateSet(this, _spread, config.spread || 10);
+    __privateSet(this, _saturation, config.saturation || 70);
+    __privateSet(this, _lightness, config.lightness || 50);
+  }
+  render(text, elapsed, context = {}) {
+    const lines = text.split("\n");
+    let charIndex = 0;
+    const time = elapsed * __privateGet(this, _speed3);
+    const colored = lines.map((line, lineIndex) => {
+      return line.split("").map((char, colIndex) => {
+        if (char === " ") return char;
+        const hue = (time + charIndex * __privateGet(this, _spread)) % 360;
+        charIndex++;
+        return `<span style="color: hsl(${hue}, ${__privateGet(this, _saturation)}%, ${__privateGet(this, _lightness)}%)">${char}</span>`;
+      }).join("");
+    });
+    const html = colored.join("<br>");
+    return { __html: html, __text: text };
+  }
+}
+_speed3 = new WeakMap();
+_spread = new WeakMap();
+_saturation = new WeakMap();
+_lightness = new WeakMap();
+const colorCycle = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ColorCycleEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class ColorGradientEffect extends BaseEffect {
+  // 'lightness', 'saturation', 'both'
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _ColorGradientEffect_instances);
+    __privateAdd(this, _baseColor, "#00aaff");
+    // Azure blue
+    __privateAdd(this, _variations, 5);
+    __privateAdd(this, _speed4, 1e-3);
+    __privateAdd(this, _mode, "lightness");
+    __privateSet(this, _baseColor, config.baseColor || "#00aaff");
+    __privateSet(this, _variations, config.variations || 5);
+    __privateSet(this, _speed4, config.speed || 1e-3);
+    __privateSet(this, _mode, config.mode || "lightness");
+  }
+  render(text, elapsed, context = {}) {
+    const lines = text.split("\n");
+    const baseHSL = __privateMethod(this, _ColorGradientEffect_instances, hexToHSL_fn).call(this, __privateGet(this, _baseColor));
+    const time = elapsed * __privateGet(this, _speed4);
+    let charIndex = 0;
+    const totalChars = text.replace(/\s/g, "").length;
+    const colored = lines.map((line) => {
+      return line.split("").map((char) => {
+        if (char === " " || char === "\n") return char;
+        const color = __privateMethod(this, _ColorGradientEffect_instances, getVariation_fn).call(this, baseHSL, charIndex, totalChars, time);
+        charIndex++;
+        return `<span style="color: ${color}">${char}</span>`;
+      }).join("");
+    });
+    const html = colored.join("<br>");
+    return { __html: html, __text: text };
+  }
+}
+_baseColor = new WeakMap();
+_variations = new WeakMap();
+_speed4 = new WeakMap();
+_mode = new WeakMap();
+_ColorGradientEffect_instances = new WeakSet();
+/**
+ * Convert hex to HSL
+ */
+hexToHSL_fn = function(hex) {
+  hex = hex.replace("#", "");
+  const r = parseInt(hex.substr(0, 2), 16) / 255;
+  const g = parseInt(hex.substr(2, 2), 16) / 255;
+  const b = parseInt(hex.substr(4, 2), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h, s, l = (max + min) / 2;
+  if (max === min) {
+    h = s = 0;
+  } else {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        break;
+      case g:
+        h = ((b - r) / d + 2) / 6;
+        break;
+      case b:
+        h = ((r - g) / d + 4) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+};
+/**
+ * Generate color variation
+ */
+getVariation_fn = function(baseHSL, index, total, time) {
+  const { h, s, l } = baseHSL;
+  const progress = index / total + time;
+  const isGrayscale = s < 5;
+  let newH = h;
+  let newS = s;
+  let newL = l;
+  switch (__privateGet(this, _mode)) {
+    case "lightness":
+      newL = 20 + progress % 1 * 60;
+      break;
+    case "saturation":
+      if (isGrayscale) {
+        newH = progress % 1 * 360;
+        newS = 30 + progress % 1 * 70;
+      } else {
+        newS = 30 + progress % 1 * 70;
+      }
+      break;
+    case "both":
+      if (isGrayscale) {
+        newH = progress % 1 * 360;
+        newL = 30 + (Math.sin(progress * Math.PI * 2) * 0.5 + 0.5) * 50;
+        newS = 40 + (Math.cos(progress * Math.PI * 2) * 0.5 + 0.5) * 60;
+      } else {
+        newL = 30 + (Math.sin(progress * Math.PI * 2) * 0.5 + 0.5) * 50;
+        newS = 40 + (Math.cos(progress * Math.PI * 2) * 0.5 + 0.5) * 60;
+      }
+      break;
+    case "hue-shift":
+      newH = (h + progress % 1 * 60 - 30 + 360) % 360;
+      break;
+  }
+  return `hsl(${newH}, ${newS}%, ${newL}%)`;
+};
+const colorGradient = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ColorGradientEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class PerspectiveEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _rotateX, 0);
+    __privateAdd(this, _rotateY, 0);
+    __privateAdd(this, _rotateZ, 0);
+    __privateAdd(this, _perspective, 1e3);
+    __privateAdd(this, _speed5, 1e-3);
+    __privateSet(this, _rotateX, config.rotateX || 0);
+    __privateSet(this, _rotateY, config.rotateY || 0);
+    __privateSet(this, _rotateZ, config.rotateZ || 0);
+    __privateSet(this, _perspective, config.perspective || 1e3);
+    __privateSet(this, _speed5, config.speed || 1e-3);
+  }
+  render(text, elapsed, context = {}) {
+    const element = context.element;
+    if (!element) return text;
+    const time = elapsed * __privateGet(this, _speed5);
+    const rx = __privateGet(this, _rotateX) * Math.sin(time);
+    const ry = __privateGet(this, _rotateY) * Math.cos(time);
+    const rz = __privateGet(this, _rotateZ) * Math.sin(time * 0.5);
+    element.style.perspective = `${__privateGet(this, _perspective)}px`;
+    element.style.transform = `rotateX(${rx}deg) rotateY(${ry}deg) rotateZ(${rz}deg)`;
+    element.style.transformStyle = "preserve-3d";
+    return text;
+  }
+}
+_rotateX = new WeakMap();
+_rotateY = new WeakMap();
+_rotateZ = new WeakMap();
+_perspective = new WeakMap();
+_speed5 = new WeakMap();
+const perspective = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PerspectiveEffect
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  colorGradient as a,
+  perspective as b,
+  colorCycle as c,
+  easing as e,
+  pulse as p,
+  wave as w
+};