zoneless-utils/fesm2022/zoneless-utils.mjs

Zoneless Utility Toolkit for Angular using Signals

import * as i0 from '@angular/core';
import { Pipe, signal, effect, Input, Directive } from '@angular/core';

// zoneless-async.pipe.ts
class ZonelessAsyncPipe {
    transform(signal) {
        return signal();
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.2", ngImport: i0, type: ZonelessAsyncPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.1.2", ngImport: i0, type: ZonelessAsyncPipe, isStandalone: true, name: "zonelessAsync", pure: false });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.2", ngImport: i0, type: ZonelessAsyncPipe, decorators: [{
            type: Pipe,
            args: [{ name: 'zonelessAsync', standalone: true, pure: false }]
        }] });

function runWithChangeDetection(cdr, callback) {
    callback();
    cdr.detectChanges();
}

function markForCheck(cdr) {
    cdr.markForCheck();
}

// use-interval.signal.ts
function useIntervalSignal(ms) {
    const counter = signal(0, ...(ngDevMode ? [{ debugName: "counter" }] : []));
    setInterval(() => counter.update(c => c + 1), ms);
    return counter;
}

// projects/zoneless-utils/src/lib/signals/use-timeout.signal.ts
function useTimeoutSignal(ms) {
    const done = signal(false, ...(ngDevMode ? [{ debugName: "done" }] : []));
    setTimeout(() => done.set(true), ms);
    return done;
}

function useAnimationFrameSignal() {
    const frame = signal(0, ...(ngDevMode ? [{ debugName: "frame" }] : []));
    function update(time) {
        frame.set(time);
        requestAnimationFrame(update);
    }
    requestAnimationFrame(update);
    return frame;
}

function useIdleSignal(timeoutMs = 30000) {
    const isIdle = signal(false, ...(ngDevMode ? [{ debugName: "isIdle" }] : []));
    let timer;
    const reset = () => {
        clearTimeout(timer);
        isIdle.set(false);
        timer = setTimeout(() => isIdle.set(true), timeoutMs);
    };
    ['mousemove', 'keydown', 'mousedown', 'touchstart'].forEach(event => window.addEventListener(event, reset));
    reset();
    return isIdle;
}

function useResizeSignal() {
    const size = signal({
        width: window.innerWidth,
        height: window.innerHeight,
    }, ...(ngDevMode ? [{ debugName: "size" }] : []));
    const update = () => {
        size.set({
            width: window.innerWidth,
            height: window.innerHeight,
        });
    };
    // Attach resize listener once
    window.addEventListener('resize', update);
    return size;
}

class ZonelessIfDirective {
    templateRef;
    viewContainer;
    hasView = false;
    constructor(templateRef, viewContainer) {
        this.templateRef = templateRef;
        this.viewContainer = viewContainer;
    }
    set zonelessIf(condition) {
        if (typeof condition === 'function') {
            effect(() => {
                this.updateView(condition());
            });
        }
        else {
            this.updateView(condition);
        }
    }
    updateView(value) {
        if (value && !this.hasView) {
            this.viewContainer.createEmbeddedView(this.templateRef);
            this.hasView = true;
        }
        else if (!value && this.hasView) {
            this.viewContainer.clear();
            this.hasView = false;
        }
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.2", ngImport: i0, type: ZonelessIfDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.2", type: ZonelessIfDirective, isStandalone: true, selector: "[zonelessIf]", inputs: { zonelessIf: "zonelessIf" }, ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.2", ngImport: i0, type: ZonelessIfDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[zonelessIf]',
                    standalone: true,
                }]
        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { zonelessIf: [{
                type: Input
            }] } });

/*
 * Public API Surface of zoneless-utils
 */

/**
 * Generated bundle index. Do not edit.
 */

export { ZonelessAsyncPipe, ZonelessIfDirective, markForCheck, runWithChangeDetection, useAnimationFrameSignal, useIdleSignal, useIntervalSignal, useResizeSignal, useTimeoutSignal };
//# sourceMappingURL=zoneless-utils.mjs.map