@jyiro/ascii-script 0.1.0

package/dist/procedural-BY9bCgT3.js

@@ -0,0 +1,66 @@
+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 _lineHeight, _opacity, _speed, _color;
+import { B as BaseEffect } from "./text-CKJIlRsq.js";
+class ScanlinesEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _lineHeight, 2);
+    __privateAdd(this, _opacity, 0.1);
+    __privateAdd(this, _speed, 0.5);
+    __privateAdd(this, _color, "rgba(0, 0, 0, 0.3)");
+    __privateSet(this, _lineHeight, config.lineHeight || 2);
+    __privateSet(this, _opacity, config.opacity || 0.1);
+    __privateSet(this, _speed, config.speed || 0.5);
+    __privateSet(this, _color, config.color || __privateGet(this, _color));
+  }
+  render(text, elapsed, context = {}) {
+    const element = context.element;
+    if (!element) return text;
+    if (!element.querySelector(".ascii-scanlines")) {
+      const overlay = document.createElement("div");
+      overlay.className = "ascii-scanlines";
+      overlay.style.cssText = `
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        pointer-events: none;
+        background: repeating-linear-gradient(
+          0deg,
+          ${__privateGet(this, _color)} 0px,
+          transparent ${__privateGet(this, _lineHeight)}px
+        );
+        opacity: ${__privateGet(this, _opacity)};
+        animation: scanlines ${__privateGet(this, _speed)}s linear infinite;
+      `;
+      if (!document.getElementById("scanlines-animation")) {
+        const style = document.createElement("style");
+        style.id = "scanlines-animation";
+        style.textContent = `
+          @keyframes scanlines {
+            0% { transform: translateY(0); }
+            100% { transform: translateY(${__privateGet(this, _lineHeight)}px); }
+          }
+        `;
+        document.head.appendChild(style);
+      }
+      element.style.position = "relative";
+      element.appendChild(overlay);
+    }
+    return text;
+  }
+}
+_lineHeight = new WeakMap();
+_opacity = new WeakMap();
+_speed = new WeakMap();
+_color = new WeakMap();
+export {
+  ScanlinesEffect
+};

package/dist/text-CKJIlRsq.js

@@ -0,0 +1,262 @@
+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 _config, _duration, _startTime, _intensity, _speed, _offsetRange, _corruptChars, _charset, _speed2, _density, _columns, _initialized, _MatrixRainEffect_instances, initColumns_fn, randomChar_fn, _charset2, _revealMode, _easingFn, _ScrambleEffect_instances, renderProgressive_fn, renderRandom_fn, randomChar_fn2, _placeholder, _easingFn2, _speed3, _cursor, _showCursor, _blinkSpeed;
+import { e as easing } from "./ascii-art-DCOQt4Se.js";
+class BaseEffect {
+  constructor(config = {}) {
+    __privateAdd(this, _config, {});
+    __privateAdd(this, _duration, 1e3);
+    __privateAdd(this, _startTime, 0);
+    __privateSet(this, _config, config);
+    __privateSet(this, _duration, config.duration || 1e3);
+  }
+  /**
+   * Render effect (override in subclasses)
+   * @param {string} text - Input text
+   * @param {number} elapsed - Time elapsed since start
+   * @param {Object} context - Additional context
+   * @returns {string} Processed text
+   */
+  render(text, elapsed, context = {}) {
+    throw new Error("render() must be implemented");
+  }
+  /**
+   * Get progress (0-1)
+   */
+  getProgress(elapsed) {
+    return Math.min(elapsed / __privateGet(this, _duration), 1);
+  }
+  get duration() {
+    return __privateGet(this, _duration);
+  }
+  get config() {
+    return __privateGet(this, _config);
+  }
+}
+_config = new WeakMap();
+_duration = new WeakMap();
+_startTime = new WeakMap();
+class GlitchEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _intensity, 0.1);
+    __privateAdd(this, _speed, 0.05);
+    __privateAdd(this, _offsetRange, 5);
+    __privateAdd(this, _corruptChars, "▓▒░█▀▄");
+    __privateSet(this, _intensity, config.intensity || 0.1);
+    __privateSet(this, _speed, config.speed || 0.05);
+    __privateSet(this, _offsetRange, config.offsetRange || 5);
+    __privateSet(this, _corruptChars, config.corruptChars || __privateGet(this, _corruptChars));
+  }
+  render(text, elapsed, context = {}) {
+    const element = context.element;
+    const lines = text.split("\n");
+    const glitched = lines.map((line, i) => {
+      if (Math.random() < __privateGet(this, _intensity)) {
+        const offset = Math.floor(Math.random() * __privateGet(this, _offsetRange) * 2) - __privateGet(this, _offsetRange);
+        const spaces = " ".repeat(Math.max(0, offset));
+        line = spaces + line;
+      }
+      return line.split("").map((char) => {
+        if (char === " " || char === "\n") return char;
+        if (Math.random() < __privateGet(this, _intensity)) {
+          return __privateGet(this, _corruptChars)[Math.floor(Math.random() * __privateGet(this, _corruptChars).length)];
+        }
+        return char;
+      }).join("");
+    });
+    if (element && Math.random() < __privateGet(this, _intensity) * 0.5) {
+      const offsetX = (Math.random() - 0.5) * 4;
+      const offsetY = (Math.random() - 0.5) * 4;
+      element.style.transform = `translate(${offsetX}px, ${offsetY}px)`;
+    } else if (element) {
+      element.style.transform = "none";
+    }
+    return glitched.join("\n");
+  }
+}
+_intensity = new WeakMap();
+_speed = new WeakMap();
+_offsetRange = new WeakMap();
+_corruptChars = new WeakMap();
+const glitch = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  GlitchEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class MatrixRainEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _MatrixRainEffect_instances);
+    __privateAdd(this, _charset, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*");
+    __privateAdd(this, _speed2, 0.05);
+    __privateAdd(this, _density, 0.05);
+    __privateAdd(this, _columns, []);
+    __privateAdd(this, _initialized, false);
+    __privateSet(this, _charset, config.charset || __privateGet(this, _charset));
+    __privateSet(this, _speed2, config.speed || 0.05);
+    __privateSet(this, _density, config.density || 0.05);
+  }
+  render(text, elapsed, context = {}) {
+    var _a;
+    const lines = text.split("\n");
+    if (!__privateGet(this, _initialized)) {
+      __privateMethod(this, _MatrixRainEffect_instances, initColumns_fn).call(this, ((_a = lines[0]) == null ? void 0 : _a.length) || 0);
+      __privateSet(this, _initialized, true);
+    }
+    const result = lines.map((line, lineIndex) => {
+      return line.split("").map((char, colIndex) => {
+        const column = __privateGet(this, _columns)[colIndex];
+        if (!column) return char;
+        column.y += __privateGet(this, _speed2);
+        if (column.y > lines.length) {
+          column.y = -Math.random() * 10;
+        }
+        if (Math.abs(lineIndex - column.y) < 1) {
+          return __privateMethod(this, _MatrixRainEffect_instances, randomChar_fn).call(this);
+        }
+        if (lineIndex > column.y && lineIndex < column.y + 5) {
+          return Math.random() < 0.3 ? __privateMethod(this, _MatrixRainEffect_instances, randomChar_fn).call(this) : char;
+        }
+        return char;
+      }).join("");
+    });
+    return result.join("\n");
+  }
+}
+_charset = new WeakMap();
+_speed2 = new WeakMap();
+_density = new WeakMap();
+_columns = new WeakMap();
+_initialized = new WeakMap();
+_MatrixRainEffect_instances = new WeakSet();
+initColumns_fn = function(width) {
+  __privateSet(this, _columns, Array(width).fill(null).map(() => ({
+    y: -Math.random() * 20,
+    speed: 0.5 + Math.random() * 0.5
+  })));
+};
+randomChar_fn = function() {
+  return __privateGet(this, _charset)[Math.floor(Math.random() * __privateGet(this, _charset).length)];
+};
+const matrixRain = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MatrixRainEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class ScrambleEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _ScrambleEffect_instances);
+    __privateAdd(this, _charset2, "!@#$%^&*()_+-=[]{}|;:,.<>?/~`");
+    __privateAdd(this, _revealMode, "progressive");
+    // 'progressive' | 'random'
+    __privateAdd(this, _easingFn, easing.easeOutQuad);
+    __privateSet(this, _charset2, config.charset || __privateGet(this, _charset2));
+    __privateSet(this, _revealMode, config.revealMode || "progressive");
+    __privateSet(this, _easingFn, easing[config.easing] || easing.easeOutQuad);
+  }
+  render(text, elapsed, context = {}) {
+    const progress = __privateGet(this, _easingFn).call(this, this.getProgress(elapsed));
+    const chars = text.split("");
+    if (__privateGet(this, _revealMode) === "progressive") {
+      return __privateMethod(this, _ScrambleEffect_instances, renderProgressive_fn).call(this, chars, progress);
+    } else {
+      return __privateMethod(this, _ScrambleEffect_instances, renderRandom_fn).call(this, chars, progress);
+    }
+  }
+}
+_charset2 = new WeakMap();
+_revealMode = new WeakMap();
+_easingFn = new WeakMap();
+_ScrambleEffect_instances = new WeakSet();
+renderProgressive_fn = function(chars, progress) {
+  const revealCount = Math.floor(chars.length * progress);
+  return chars.map((char, i) => {
+    if (i < revealCount) return char;
+    if (char === " " || char === "\n") return char;
+    return __privateMethod(this, _ScrambleEffect_instances, randomChar_fn2).call(this);
+  }).join("");
+};
+renderRandom_fn = function(chars, progress) {
+  return chars.map((char) => {
+    if (char === " " || char === "\n") return char;
+    if (Math.random() < progress) return char;
+    return __privateMethod(this, _ScrambleEffect_instances, randomChar_fn2).call(this);
+  }).join("");
+};
+randomChar_fn2 = function() {
+  return __privateGet(this, _charset2)[Math.floor(Math.random() * __privateGet(this, _charset2).length)];
+};
+const scramble = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ScrambleEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class RevealEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _placeholder, "█");
+    __privateAdd(this, _easingFn2, easing.easeOutCubic);
+    __privateSet(this, _placeholder, config.placeholder || "█");
+    __privateSet(this, _easingFn2, easing[config.easing] || easing.easeOutCubic);
+  }
+  render(text, elapsed, context = {}) {
+    const progress = __privateGet(this, _easingFn2).call(this, this.getProgress(elapsed));
+    const chars = text.split("");
+    const revealCount = Math.floor(chars.length * progress);
+    return chars.map((char, i) => {
+      if (i < revealCount) return char;
+      if (char === " " || char === "\n") return char;
+      return __privateGet(this, _placeholder);
+    }).join("");
+  }
+}
+_placeholder = new WeakMap();
+_easingFn2 = new WeakMap();
+const reveal = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RevealEffect
+}, Symbol.toStringTag, { value: "Module" }));
+class TypewriterEffect extends BaseEffect {
+  constructor(config = {}) {
+    super(config);
+    __privateAdd(this, _speed3, 50);
+    // ms per character
+    __privateAdd(this, _cursor, "|");
+    __privateAdd(this, _showCursor, true);
+    __privateAdd(this, _blinkSpeed, 500);
+    __privateSet(this, _speed3, config.speed || 50);
+    __privateSet(this, _cursor, config.cursor || "|");
+    __privateSet(this, _showCursor, config.showCursor !== false);
+    __privateSet(this, _blinkSpeed, config.blinkSpeed || 500);
+  }
+  render(text, elapsed, context = {}) {
+    const charCount = Math.floor(elapsed / __privateGet(this, _speed3));
+    const revealed = text.slice(0, Math.min(charCount, text.length));
+    if (__privateGet(this, _showCursor) && charCount < text.length) {
+      const blink = Math.floor(elapsed / __privateGet(this, _blinkSpeed)) % 2 === 0;
+      return revealed + (blink ? __privateGet(this, _cursor) : "");
+    }
+    return revealed;
+  }
+}
+_speed3 = new WeakMap();
+_cursor = new WeakMap();
+_showCursor = new WeakMap();
+_blinkSpeed = new WeakMap();
+const typewriter = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TypewriterEffect
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  BaseEffect as B,
+  glitch as g,
+  matrixRain as m,
+  reveal as r,
+  scramble as s,
+  typewriter as t
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@jyiro/ascii-script",
+  "version": "0.1.0",
+  "description": "Micro-librería para render y animación ASCII en el DOM",
+  "type": "module",
+  "main": "./dist/ascii-script.js",
+  "module": "./dist/ascii-script.js",
+  "exports": {
+    ".": {
+      "import": "./dist/ascii-script.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "lint": "eslint src --ext .js",
+    "preview": "vite preview"
+  },
+  "keywords": [
+    "ascii",
+    "animation",
+    "effects",
+    "dom",
+    "canvas",
+    "art"
+  ],
+  "author": "Jyiro <https://github.com/Jyiro>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jyiro/ascii-script.git"
+  },
+  "homepage": "https://github.com/Jyiro/ascii-script#readme",
+  "bugs": {
+    "url": "https://github.com/Jyiro/ascii-script/issues"
+  },
+  "devDependencies": {
+    "eslint": "^8.56.0",
+    "happy-dom": "^20.6.1",
+    "jsdom": "^28.1.0",
+    "vite": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}