@nmmty/lazycanvas 0.6.5 → 1.0.0-dev.4

package/dist/core/SignalUtils.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeline = void 0;
+exports.all = all;
+exports.chain = chain;
+exports.loop = loop;
+exports.loopFor = loopFor;
+exports.waitFor = waitFor;
+exports.delay = delay;
+exports.any = any;
+exports.conditional = conditional;
+exports.repeatWhile = repeatWhile;
+exports.every = every;
+exports.spring = spring;
+exports.sequence = sequence;
+exports.yoyo = yoyo;
+exports.timeline = timeline;
+exports.calculateDuration = calculateDuration;
+exports.calculateParallelDuration = calculateParallelDuration;
+exports.calculateSequentialDuration = calculateSequentialDuration;
+/**
+ * Storage for animation duration metadata
+ */
+const animationDurations = new WeakMap();
+/**
+ * Run multiple animations in parallel
+ * @param generators - Array of animation generators
+ */
+function* all(...generators) {
+    const active = [...generators];
+    // Initialize all generators before starting
+    for (const gen of active) {
+        gen.next(); // Prime the generator
+    }
+    while (active.length > 0) {
+        const delta = yield;
+        for (let i = active.length - 1; i >= 0; i--) {
+            const result = active[i].next(delta);
+            if (result.done) {
+                active.splice(i, 1);
+            }
+        }
+    }
+}
+/**
+ * Run animations in sequence
+ * @param generators - Array of animation generators
+ */
+function* chain(...generators) {
+    for (const generator of generators) {
+        yield* generator;
+    }
+}
+/**
+ * Run animation in a loop
+ * @param generator - Animation generator factory
+ * @param times - Number of iterations (Infinity for endless)
+ */
+function* loop(generator, times = Infinity) {
+    let count = 0;
+    while (count < times) {
+        yield* generator();
+        count++;
+    }
+}
+/**
+ * Run animation for a specific duration
+ * @param generator - Animation generator factory
+ * @param duration - Total duration in seconds
+ */
+function* loopFor(generator, duration) {
+    let elapsed = 0;
+    while (elapsed < duration) {
+        const gen = generator();
+        let result = gen.next();
+        while (!result.done && elapsed < duration) {
+            const delta = yield;
+            const actualDelta = typeof delta === "number" ? delta : 1 / 60;
+            elapsed += actualDelta;
+            result = gen.next(delta);
+        }
+        // If animation finished before duration, restart
+        if (result.done && elapsed < duration) {
+            // Loop continues
+        }
+        else {
+            break;
+        }
+    }
+}
+/**
+ * Wait for a specific duration
+ * @param duration - Duration in seconds
+ */
+function* waitFor(duration) {
+    let elapsed = 0;
+    while (elapsed < duration) {
+        const delta = yield;
+        const actualDelta = typeof delta === "number" ? delta : 1 / 60;
+        elapsed += actualDelta;
+    }
+}
+/**
+ * Delay an animation by a specific duration
+ * @param duration - Delay in seconds
+ * @param generator - Animation generator
+ */
+function* delay(duration, generator) {
+    yield* waitFor(duration);
+    yield* generator;
+}
+/**
+ * Run animations until any one completes
+ * @param generators - Array of animation generators
+ */
+function* any(...generators) {
+    const active = [...generators];
+    while (active.length > 0) {
+        const delta = yield;
+        for (const gen of active) {
+            const result = gen.next(delta);
+            if (result.done) {
+                // Cancel all other generators
+                return;
+            }
+        }
+    }
+}
+/**
+ * Conditional animation
+ * @param condition - Condition function
+ * @param trueGen - Generator if condition is true
+ * @param falseGen - Generator if condition is false
+ */
+function* conditional(condition, trueGen, falseGen) {
+    if (condition()) {
+        yield* trueGen;
+    }
+    else if (falseGen) {
+        yield* falseGen;
+    }
+}
+/**
+ * Repeat animation while condition is true
+ * @param condition - Condition function
+ * @param generator - Animation generator factory
+ */
+function* repeatWhile(condition, generator) {
+    while (condition()) {
+        yield* generator();
+    }
+}
+/**
+ * Run animation at specific intervals
+ * @param interval - Interval duration in seconds
+ * @param generator - Animation generator factory
+ * @param times - Number of times to run (Infinity for endless)
+ */
+function* every(interval, generator, times = Infinity) {
+    let count = 0;
+    while (count < times) {
+        yield* generator();
+        yield* waitFor(interval);
+        count++;
+    }
+}
+/**
+ * Spring animation utility
+ * @param signal - Signal to animate
+ * @param target - Target value
+ * @param config - Spring configuration
+ */
+function* spring(signal, target, config = {}) {
+    const stiffness = config.stiffness ?? 170;
+    const damping = config.damping ?? 26;
+    const mass = config.mass ?? 1;
+    const precision = config.precision ?? 0.01;
+    // Only works for numbers
+    if (typeof signal.value() !== "number" || typeof target !== "number") {
+        signal.set(target);
+        return;
+    }
+    let position = signal.value();
+    let velocity = 0;
+    const targetNum = target;
+    while (Math.abs(position - targetNum) > precision || Math.abs(velocity) > precision) {
+        const delta = yield;
+        const actualDelta = typeof delta === "number" ? delta : 1 / 60;
+        const force = -stiffness * (position - targetNum);
+        const dampingForce = -damping * velocity;
+        const acceleration = (force + dampingForce) / mass;
+        velocity += acceleration * actualDelta;
+        position += velocity * actualDelta;
+        signal.set(position);
+    }
+    signal.set(target);
+}
+/**
+ * Tween between multiple values in sequence
+ * @param signal - Signal to animate
+ * @param values - Array of target values
+ * @param duration - Duration for each tween
+ * @param config - Tween configuration
+ */
+function* sequence(signal, values, duration, config) {
+    for (const value of values) {
+        yield* signal.to(value, duration, config);
+    }
+}
+/**
+ * Animate signal back and forth
+ * @param signal - Signal to animate
+ * @param from - Start value
+ * @param to - End value
+ * @param duration - Duration for each direction
+ * @param config - Tween configuration
+ */
+function* yoyo(signal, from, to, duration, config) {
+    signal.set(from);
+    yield* signal.to(to, duration, config);
+    yield* signal.to(from, duration, config);
+}
+/**
+ * Create a timeline builder for complex animations
+ */
+class Timeline {
+    constructor() {
+        this.generators = [];
+        this.currentTime = 0;
+    }
+    /**
+     * Add animation at specific time
+     */
+    at(time, generator) {
+        this.generators.push({ time, generator });
+        return this;
+    }
+    /**
+     * Add animation after previous
+     */
+    then(generator) {
+        this.generators.push({ time: this.currentTime, generator });
+        return this;
+    }
+    /**
+     * Set current time cursor
+     */
+    seek(time) {
+        this.currentTime = time;
+        return this;
+    }
+    /**
+     * Execute timeline
+     */
+    *play() {
+        // Sort by time
+        const sorted = [...this.generators].sort((a, b) => a.time - b.time);
+        let time = 0;
+        let activeGens = [];
+        let nextIndex = 0;
+        while (nextIndex < sorted.length || activeGens.length > 0) {
+            const delta = yield;
+            const actualDelta = typeof delta === "number" ? delta : 1 / 60;
+            time += actualDelta;
+            // Start new generators that should be active now
+            while (nextIndex < sorted.length && sorted[nextIndex].time <= time) {
+                activeGens.push(sorted[nextIndex].generator);
+                nextIndex++;
+            }
+            // Update active generators
+            for (let i = activeGens.length - 1; i >= 0; i--) {
+                const result = activeGens[i].next(delta);
+                if (result.done) {
+                    activeGens.splice(i, 1);
+                }
+            }
+        }
+    }
+}
+exports.Timeline = Timeline;
+/**
+ * Create a timeline
+ */
+function timeline() {
+    return new Timeline();
+}
+/**
+ * Calculate the total duration of an animation by running it with a fixed timestep
+ * @param generatorFactory - Function that creates the animation generator
+ * @param maxDuration - Maximum duration to simulate (safety limit, default: 3600s = 1 hour)
+ * @param timestep - Simulation timestep in seconds (default: 1/60)
+ * @returns Total duration in seconds
+ */
+function calculateDuration(generatorFactory, maxDuration = 3600, timestep = 1 / 60) {
+    const gen = generatorFactory();
+    let totalTime = 0;
+    // Initialize generator
+    gen.next();
+    // Run generator until completion
+    let result = gen.next(timestep);
+    while (!result.done && totalTime < maxDuration) {
+        totalTime += timestep;
+        result = gen.next(timestep);
+    }
+    if (totalTime >= maxDuration) {
+        console.warn(`Animation duration calculation reached maximum limit of ${maxDuration}s. Animation may be infinite or very long.`);
+    }
+    return totalTime;
+}
+/**
+ * Calculate duration from multiple animation factories running in parallel
+ * Returns the duration of the longest animation
+ */
+function calculateParallelDuration(generatorFactories, maxDuration = 3600, timestep = 1 / 60) {
+    const durations = generatorFactories.map((factory) => calculateDuration(factory, maxDuration, timestep));
+    return Math.max(...durations);
+}
+/**
+ * Calculate duration from multiple animation factories running in sequence
+ * Returns the sum of all animation durations
+ */
+function calculateSequentialDuration(generatorFactories, maxDuration = 3600, timestep = 1 / 60) {
+    let totalDuration = 0;
+    for (const factory of generatorFactories) {
+        const duration = calculateDuration(factory, maxDuration - totalDuration, timestep);
+        totalDuration += duration;
+        if (totalDuration >= maxDuration) {
+            console.warn(`Sequential animation duration calculation reached maximum limit of ${maxDuration}s.`);
+            break;
+        }
+    }
+    return totalDuration;
+}

package/dist/core/ThreadScheduler.d.ts

@@ -0,0 +1,38 @@
+import { ThreadGenerator } from "./Signal";
+/**
+ * Thread scheduler for managing animation generators
+ */
+export declare class ThreadScheduler {
+    private threads;
+    private currentTime;
+    private lastUpdateTime;
+    private initialized;
+    /**
+     * Add a thread to the scheduler
+     */
+    add(thread: ThreadGenerator): void;
+    /**
+     * Remove a thread from the scheduler
+     */
+    remove(thread: ThreadGenerator): void;
+    /**
+     * Update all threads with delta time
+     */
+    update(time: number): void;
+    /**
+     * Clear all threads
+     */
+    clear(): void;
+    /**
+     * Get current time
+     */
+    getTime(): number;
+    /**
+     * Reset time
+     */
+    reset(): void;
+    /**
+     * Check if scheduler has active threads
+     */
+    hasActiveThreads(): boolean;
+}

package/dist/core/ThreadScheduler.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadScheduler = void 0;
+/**
+ * Thread scheduler for managing animation generators
+ */
+class ThreadScheduler {
+    constructor() {
+        this.threads = new Set();
+        this.currentTime = 0;
+        this.lastUpdateTime = 0;
+        this.initialized = false;
+    }
+    /**
+     * Add a thread to the scheduler
+     */
+    add(thread) {
+        this.threads.add(thread);
+    }
+    /**
+     * Remove a thread from the scheduler
+     */
+    remove(thread) {
+        this.threads.delete(thread);
+    }
+    /**
+     * Update all threads with delta time
+     */
+    update(time) {
+        // Calculate delta
+        const delta = this.initialized ? time - this.lastUpdateTime : 0;
+        this.lastUpdateTime = time;
+        this.currentTime = time;
+        this.initialized = true;
+        const threadsToRemove = [];
+        for (const thread of this.threads) {
+            const result = thread.next(delta);
+            if (result.done) {
+                threadsToRemove.push(thread);
+            }
+        }
+        // Remove completed threads
+        for (const thread of threadsToRemove) {
+            this.threads.delete(thread);
+        }
+    }
+    /**
+     * Clear all threads
+     */
+    clear() {
+        this.threads.clear();
+    }
+    /**
+     * Get current time
+     */
+    getTime() {
+        return this.currentTime;
+    }
+    /**
+     * Reset time
+     */
+    reset() {
+        this.currentTime = 0;
+        this.lastUpdateTime = 0;
+        this.initialized = false;
+    }
+    /**
+     * Check if scheduler has active threads
+     */
+    hasActiveThreads() {
+        return this.threads.size > 0;
+    }
+}
+exports.ThreadScheduler = ThreadScheduler;

package/dist/helpers/Filters.js

@@ -87,5 +87,5 @@ exports.Filters = {
      */
     sepia(amount) {
         return `sepia(${amount}%)`;
-    }
+    },
 };

package/dist/helpers/FontsList.js

@@ -9,57 +9,57 @@ const types_1 = require("../types");
  */
 exports.FontsList = {
     Geist_Thin(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Thin };
+        return { family: "Geist", size, weight: types_1.FontWeight.Thin };
     },
     Geist_ExtraLight(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.ExtraLight };
+        return { family: "Geist", size, weight: types_1.FontWeight.ExtraLight };
     },
     Geist_Light(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Light };
+        return { family: "Geist", size, weight: types_1.FontWeight.Light };
     },
     Geist_Regular(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Regular };
+        return { family: "Geist", size, weight: types_1.FontWeight.Regular };
     },
     Geist_Medium(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Medium };
+        return { family: "Geist", size, weight: types_1.FontWeight.Medium };
     },
     Geist_SemiBold(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.SemiBold };
+        return { family: "Geist", size, weight: types_1.FontWeight.SemiBold };
     },
     Geist_Bold(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Bold };
+        return { family: "Geist", size, weight: types_1.FontWeight.Bold };
     },
     Geist_ExtraBold(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.ExtraBold };
+        return { family: "Geist", size, weight: types_1.FontWeight.ExtraBold };
     },
     Geist_Black(size) {
-        return { family: 'Geist', size, weight: types_1.FontWeight.Black };
+        return { family: "Geist", size, weight: types_1.FontWeight.Black };
     },
     GeistMono_Thin(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Thin };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Thin };
     },
     GeistMono_ExtraLight(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.ExtraLight };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.ExtraLight };
     },
     GeistMono_Light(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Light };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Light };
     },
     GeistMono_Regular(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Regular };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Regular };
     },
     GeistMono_Medium(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Medium };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Medium };
     },
     GeistMono_SemiBold(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.SemiBold };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.SemiBold };
     },
     GeistMono_Bold(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Bold };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Bold };
     },
     GeistMono_Black(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.Black };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.Black };
     },
     GeistMono_ExtraBlack(size) {
-        return { family: 'GeistMono', size, weight: types_1.FontWeight.ExtraBlack };
+        return { family: "GeistMono", size, weight: types_1.FontWeight.ExtraBlack };
     },
 };

package/dist/helpers/Utlis.d.ts

@@ -1,17 +1,17 @@
-import { Group } from "../structures/components";
+import { Div } from "../structures/components";
 import { ColorType } from "../types";
 declare const Utils: {
     grid(size: {
         x: number;
         y: number;
-    }, opts?: gridOptions): Group;
+    }, opts?: gridOptions): Div;
     box(start: {
         x: number;
         y: number;
     }, end: {
         x: number;
         y: number;
-    }, opts?: options): Group;
+    }, opts?: options): Div;
 };
 interface options {
     color?: ColorType;

package/dist/helpers/Utlis.js

@@ -22,57 +22,54 @@ const Utils = {
         if (opts.endY === undefined)
             opts.endY = size.y;
         if (opts.color === undefined)
-            opts.color = 'rgba(0, 0, 0, 0.5)';
+            opts.color = "rgba(0, 0, 0, 0.5)";
         if (opts.lineWidth === undefined)
             opts.lineWidth = 1;
         const options = { ...opts };
-        return new components_1.Group()
+        return new components_1.Div()
             .setID(`grid-${options.cellWith}-${options.cellHeight}-${options.startX}-${options.startY}-${options.endX}-${options.endY}`)
             .add(...Array.from({ length: Math.ceil((options.endX - options.startX) / options.cellWith) }, (_, i) => {
             const x = options.startX + i * options.cellWith;
             return new components_1.LineLayer()
-                .setPosition(x, options.startY)
-                .setEndPosition(x, options.endY)
+                .setPosition(x, options.startY, x, options.endY)
                 .setColor(options.color)
                 .setStroke(options.lineWidth);
         }), ...Array.from({ length: Math.ceil((options.endY - options.startY) / options.cellHeight) }, (_, i) => {
             const y = options.startY + i * options.cellHeight;
             return new components_1.LineLayer()
-                .setPosition(options.startX, y)
-                .setEndPosition(options.endX, y)
+                .setPosition(options.startX, y, options.endX, y)
                 .setColor(options.color)
                 .setStroke(options.lineWidth);
         }));
     },
     box(start, end, opts) {
-        if (start.x === undefined || start.y === undefined || end.x === undefined || end.y === undefined) {
+        if (start.x === undefined ||
+            start.y === undefined ||
+            end.x === undefined ||
+            end.y === undefined) {
             throw new Error("Start and end must have x and y properties");
         }
         if (opts === undefined)
             opts = {};
         if (opts.color === undefined)
-            opts.color = 'rgba(0, 0, 0, 0.5)';
+            opts.color = "rgba(0, 0, 0, 0.5)";
         if (opts.lineWidth === undefined)
             opts.lineWidth = 1;
-        return new components_1.Group()
+        return new components_1.Div()
             .setID(`box-${start.x}-${start.y}-${end.x}-${end.y}`)
             .add(new components_1.LineLayer()
-            .setPosition(start.x, start.y)
-            .setEndPosition(end.x, start.y)
+            .setPosition(start.x, start.y, end.x, start.y)
             .setColor(opts.color)
             .setStroke(opts.lineWidth), new components_1.LineLayer()
-            .setPosition(end.x, start.y)
-            .setEndPosition(end.x, end.y)
+            .setPosition(end.x, start.y, end.x, end.y)
             .setColor(opts.color)
             .setStroke(opts.lineWidth), new components_1.LineLayer()
-            .setPosition(end.x, end.y)
-            .setEndPosition(start.x, end.y)
+            .setPosition(end.x, end.y, start.x, end.y)
             .setColor(opts.color)
             .setStroke(opts.lineWidth), new components_1.LineLayer()
-            .setPosition(start.x, end.y)
-            .setEndPosition(start.x, start.y)
+            .setPosition(start.x, end.y, start.x, start.y)
             .setColor(opts.color)
             .setStroke(opts.lineWidth));
-    }
+    },
 };
 exports.Utils = Utils;

package/dist/helpers/index.d.ts

@@ -1,3 +1,3 @@
-export * from './Utlis';
-export * from './Filters';
-export * from './FontsList';
+export * from "./Utlis";
+export * from "./Filters";
+export * from "./FontsList";

package/dist/index.d.ts

@@ -4,3 +4,13 @@ export * from "./structures/components";
 export * from "./types";
 export * from "./structures/helpers";
 export * from "./helpers";
+export * from "./core/Scene";
+export * from "./core/Signal";
+export * from "./core/SignalUtils";
+export * from "./core/ThreadScheduler";
+export * from "./core/Interpolation";
+export * from "./utils/APNGEncoder";
+export * from "./utils/DrawUtils";
+export * from "./utils/LazyUtil";
+export * from "./utils/utils";
+export * from "./jsx-runtime";

package/dist/index.js

@@ -20,3 +20,13 @@ __exportStar(require("./structures/components"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./structures/helpers"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./core/Scene"), exports);
+__exportStar(require("./core/Signal"), exports);
+__exportStar(require("./core/SignalUtils"), exports);
+__exportStar(require("./core/ThreadScheduler"), exports);
+__exportStar(require("./core/Interpolation"), exports);
+__exportStar(require("./utils/APNGEncoder"), exports);
+__exportStar(require("./utils/DrawUtils"), exports);
+__exportStar(require("./utils/LazyUtil"), exports);
+__exportStar(require("./utils/utils"), exports);
+__exportStar(require("./jsx-runtime"), exports);

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSX createElement factory for LazyCanvas components
+ * Compatible with "jsx": "react" in tsconfig.json
+ */
+export declare function createElement(type: any, props: any | null, ...children: any[]): any;
+/**
+ * Fragment component for grouping elements without creating a Group layer
+ */
+export declare function Fragment(props: {
+    children: any[];
+}): any[];
+/**
+ * Export for compatibility with some JSX runtimes
+ */
+export declare const jsx: typeof createElement;
+export declare const jsxs: typeof createElement;
+export declare const jsxDEV: typeof createElement;