@fluffjs/fluff 0.0.3

package/decorators/Component.d.ts

@@ -0,0 +1,24 @@
+interface PipeInstance {
+    transform: (value: unknown, ...args: unknown[]) => unknown;
+}
+interface PipeClass {
+    __pipeName?: string;
+    new (): PipeInstance;
+}
+type Constructor = new (...args: unknown[]) => object;
+export interface ComponentConfig {
+    selector: string;
+    templateUrl?: string;
+    template?: string;
+    styleUrl?: string;
+    styles?: string;
+    pipes?: PipeClass[];
+}
+export interface ComponentMetadata extends ComponentConfig {
+    inputs: Map<string, string>;
+    outputs: Map<string, string>;
+}
+export declare function Component(config: ComponentConfig): <T extends Constructor>(target: T) => T;
+export declare function getComponentMetadata(target: Constructor): ComponentMetadata | undefined;
+export declare function getAllComponents(): Map<Constructor, ComponentMetadata>;
+export {};

package/decorators/Component.js

@@ -0,0 +1,27 @@
+const componentRegistry = new Map();
+export function Component(config) {
+    return function (target) {
+        const metadata = {
+            ...config, inputs: new Map(), outputs: new Map()
+        };
+        componentRegistry.set(target, metadata);
+        if (config.pipes && config.pipes.length > 0) {
+            const pipesObj = {};
+            for (const PipeClassItem of config.pipes) {
+                const pipeName = PipeClassItem.__pipeName;
+                if (pipeName) {
+                    const instance = new PipeClassItem();
+                    pipesObj[pipeName] = (value, ...args) => instance.transform(value, ...args);
+                }
+            }
+            Reflect.set(target.prototype, '__pipes', pipesObj);
+        }
+        return target;
+    };
+}
+export function getComponentMetadata(target) {
+    return componentRegistry.get(target);
+}
+export function getAllComponents() {
+    return componentRegistry;
+}

package/decorators/HostBinding.d.ts

@@ -0,0 +1 @@
+export declare function HostBinding(hostProperty: string): PropertyDecorator;

package/decorators/HostBinding.js

@@ -0,0 +1,15 @@
+function isHostBindingArray(val) {
+    return Array.isArray(val);
+}
+export function HostBinding(hostProperty) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const key = String(propertyKey);
+        const existing = Reflect.get(ctor, '__hostBindings');
+        const bindings = isHostBindingArray(existing) ? existing : [];
+        if (!isHostBindingArray(existing)) {
+            Reflect.set(ctor, '__hostBindings', bindings);
+        }
+        bindings.push({ property: key, hostProperty });
+    };
+}

package/decorators/HostListener.d.ts

@@ -0,0 +1 @@
+export declare function HostListener(eventName: string): MethodDecorator;

package/decorators/HostListener.js

@@ -0,0 +1,16 @@
+function isHostListenerArray(val) {
+    return Array.isArray(val);
+}
+export function HostListener(eventName) {
+    return function (target, propertyKey, descriptor) {
+        const ctor = target.constructor;
+        const key = String(propertyKey);
+        const existing = Reflect.get(ctor, '__hostListeners');
+        const listeners = isHostListenerArray(existing) ? existing : [];
+        if (!isHostListenerArray(existing)) {
+            Reflect.set(ctor, '__hostListeners', listeners);
+        }
+        listeners.push({ method: key, event: eventName });
+        return descriptor;
+    };
+}

package/decorators/Input.d.ts

@@ -0,0 +1 @@
+export declare function Input(bindingName?: string): PropertyDecorator;

package/decorators/Input.js

@@ -0,0 +1,16 @@
+import { getComponentMetadata } from './Component.js';
+function isConstructor(val) {
+    return typeof val === 'function';
+}
+export function Input(bindingName) {
+    return function (target, propertyKey) {
+        const { constructor } = target;
+        if (!isConstructor(constructor))
+            return;
+        const metadata = getComponentMetadata(constructor);
+        if (metadata) {
+            const name = bindingName ?? String(propertyKey);
+            metadata.inputs.set(String(propertyKey), name);
+        }
+    };
+}

package/decorators/Output.d.ts

@@ -0,0 +1 @@
+export declare function Output(bindingName?: string): PropertyDecorator;

package/decorators/Output.js

@@ -0,0 +1,16 @@
+import { getComponentMetadata } from './Component.js';
+function isConstructor(val) {
+    return typeof val === 'function';
+}
+export function Output(bindingName) {
+    return function (target, propertyKey) {
+        const { constructor } = target;
+        if (!isConstructor(constructor))
+            return;
+        const metadata = getComponentMetadata(constructor);
+        if (metadata) {
+            const name = bindingName ?? String(propertyKey);
+            metadata.outputs.set(String(propertyKey), name);
+        }
+    };
+}

package/decorators/Pipe.d.ts

@@ -0,0 +1,8 @@
+type PipeConstructor = (new (...args: unknown[]) => unknown) & {
+    __pipeName?: string;
+};
+export declare function Pipe(name: string): <T extends PipeConstructor>(target: T) => T;
+export interface PipeTransform<TArgs extends unknown[] = unknown[], TReturn = unknown> {
+    transform: (value: unknown, ...args: TArgs) => TReturn;
+}
+export {};

package/decorators/Pipe.js

@@ -0,0 +1,6 @@
+export function Pipe(name) {
+    return function (target) {
+        target.__pipeName = name;
+        return target;
+    };
+}

package/decorators/Reactive.d.ts

@@ -0,0 +1 @@
+export declare function Reactive(): PropertyDecorator;

package/decorators/Reactive.js

@@ -0,0 +1,5 @@
+export function Reactive() {
+    return (_target, _propertyKey) => {
+        // Dummy decorator, replaced by compiler
+    };
+}

package/decorators/ViewChild.d.ts

@@ -0,0 +1 @@
+export declare function ViewChild(refOrSelector: string): PropertyDecorator;

package/decorators/ViewChild.js

@@ -0,0 +1,15 @@
+function isViewChildArray(val) {
+    return Array.isArray(val);
+}
+export function ViewChild(refOrSelector) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const key = String(propertyKey);
+        const existing = Reflect.get(ctor, '__viewChildren');
+        const children = isViewChildArray(existing) ? existing : [];
+        if (!isViewChildArray(existing)) {
+            Reflect.set(ctor, '__viewChildren', children);
+        }
+        children.push({ property: key, selector: refOrSelector });
+    };
+}

package/decorators/Watch.d.ts

@@ -0,0 +1 @@
+export declare function Watch(..._properties: string[]): MethodDecorator;

package/decorators/Watch.js

@@ -0,0 +1,9 @@
+export function Watch(..._properties) {
+    return function (target, propertyKey, descriptor) {
+        const original = descriptor.value;
+        if (typeof original === 'function') {
+            Reflect.set(target, `__watch_${String(propertyKey)}`, original);
+        }
+        return descriptor;
+    };
+}

package/enums/Direction.d.ts

@@ -0,0 +1,5 @@
+export declare const enum Direction {
+    Any = 0,
+    Inbound = 1,
+    Outbound = 2
+}

package/enums/Direction.js

@@ -0,0 +1,6 @@
+export var Direction;
+(function (Direction) {
+    Direction[Direction["Any"] = 0] = "Any";
+    Direction[Direction["Inbound"] = 1] = "Inbound";
+    Direction[Direction["Outbound"] = 2] = "Outbound";
+})(Direction || (Direction = {}));

package/index.d.ts

@@ -0,0 +1,18 @@
+export { Component } from './decorators/Component.js';
+export type { ComponentConfig, ComponentMetadata } from './decorators/Component.js';
+export { HostBinding } from './decorators/HostBinding.js';
+export { HostListener } from './decorators/HostListener.js';
+export { Input } from './decorators/Input.js';
+export { Output } from './decorators/Output.js';
+export { Pipe } from './decorators/Pipe.js';
+export type { PipeTransform } from './decorators/Pipe.js';
+export { Reactive } from './decorators/Reactive.js';
+export { ViewChild } from './decorators/ViewChild.js';
+export { Watch } from './decorators/Watch.js';
+export { FluffElement } from './runtime/FluffElement.js';
+export { Property } from './utils/Property.js';
+export { Publisher } from './utils/Publisher.js';
+export { Direction } from './enums/Direction.js';
+export type { OnInit } from './interfaces/OnInit.js';
+export type { OnDestroy } from './interfaces/OnDestroy.js';
+export type { Subscription } from './interfaces/Subscription.js';

package/index.js

@@ -0,0 +1,13 @@
+export { Component } from './decorators/Component.js';
+export { HostBinding } from './decorators/HostBinding.js';
+export { HostListener } from './decorators/HostListener.js';
+export { Input } from './decorators/Input.js';
+export { Output } from './decorators/Output.js';
+export { Pipe } from './decorators/Pipe.js';
+export { Reactive } from './decorators/Reactive.js';
+export { ViewChild } from './decorators/ViewChild.js';
+export { Watch } from './decorators/Watch.js';
+export { FluffElement } from './runtime/FluffElement.js';
+export { Property } from './utils/Property.js';
+export { Publisher } from './utils/Publisher.js';
+export { Direction } from './enums/Direction.js';

package/interfaces/OnDestroy.d.ts

@@ -0,0 +1,3 @@
+export interface OnDestroy {
+    onDestroy: () => void;
+}

package/interfaces/OnDestroy.js

@@ -0,0 +1 @@
+export {};

package/interfaces/OnInit.d.ts

@@ -0,0 +1,3 @@
+export interface OnInit {
+    onInit: () => void;
+}

package/interfaces/OnInit.js

@@ -0,0 +1 @@
+export {};

package/interfaces/Subscription.d.ts

@@ -0,0 +1,3 @@
+export interface Subscription {
+    unsubscribe: () => void;
+}

package/interfaces/Subscription.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@fluffjs/fluff",
+  "version": "0.0.3",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "!*.tsbuildinfo"
+  ],
+  "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/runtime/FluffElement.d.ts

@@ -0,0 +1,39 @@
+import type { Subscription } from '../interfaces/Subscription.js';
+import type { Property } from '../utils/Property.js';
+import type { Publisher } from '../utils/Publisher.js';
+export declare abstract class FluffElement extends HTMLElement {
+    protected __pipes: Record<string, (value: unknown, ...args: unknown[]) => unknown>;
+    private _subscriptions;
+    protected readonly _shadowRoot: ShadowRoot;
+    private _initialized;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected abstract __render(): void;
+    protected abstract __setupBindings(): void;
+    protected __addSubscription(sub: Subscription): void;
+    protected __pipe(name: string, value: unknown, ...args: unknown[]): unknown;
+    $watch: (_properties: string[], callback: () => void) => Subscription;
+    protected __getShadowRoot(): ShadowRoot;
+    protected __getElement(id: string): Element | null;
+    private isHTMLElement;
+    private isPublisher;
+    private isProperty;
+    protected __setText(id: string, text: string): void;
+    protected __bindText(id: string, getter: () => string): void;
+    protected __setProperty(id: string, prop: string, value: unknown): void;
+    protected __addClass(id: string, className: string): void;
+    protected __removeClass(id: string, className: string): void;
+    protected __bindEvent(id: string, event: string, handler: (e: Event) => void): void;
+    protected __bindPropertyChange<T>(prop: Property<T>, callback: (val: T) => void): void;
+    protected __connectProperties<T>(source: Property<T>, target: Property<T>): void;
+    protected __connectOutput<T>(source: Publisher<T>, handler: (val: T) => void): void;
+    protected __bindOutput(id: string, outputName: string, handler: (val: Event) => void): void;
+    protected __setChildProperty(el: Element, propName: string, value: unknown): void;
+    protected __bindToChild(id: string, propName: string, value: unknown): void;
+    protected __setChildPropertyDeferred(el: Element, propName: string, value: unknown): void;
+    protected __bindOutputOnElement(el: Element, outputName: string, handler: (val: Event) => void): void;
+    protected __wireEvents(container: Element, attrPrefix: string): void;
+    private __buildRefLookups;
+    private __getReactiveProp;
+}

package/runtime/FluffElement.js

@@ -0,0 +1,272 @@
+export class FluffElement extends HTMLElement {
+    __pipes = {};
+    _subscriptions = [];
+    _shadowRoot;
+    _initialized = false;
+    constructor() {
+        super();
+        this._shadowRoot = this.attachShadow({ mode: 'open' });
+    }
+    connectedCallback() {
+        if (!this._initialized) {
+            this.__render();
+            this.__setupBindings();
+            this._initialized = true;
+            if ('onInit' in this && typeof this.onInit === 'function') {
+                this.onInit();
+            }
+        }
+    }
+    disconnectedCallback() {
+        if ('onDestroy' in this && typeof this.onDestroy === 'function') {
+            this.onDestroy();
+        }
+        for (const sub of this._subscriptions) {
+            sub.unsubscribe();
+        }
+        this._subscriptions = [];
+    }
+    __addSubscription(sub) {
+        this._subscriptions.push(sub);
+    }
+    __pipe(name, value, ...args) {
+        const pipe = this.__pipes[name];
+        if (!pipe) {
+            console.warn(`Pipe "${name}" not found`);
+            return value;
+        }
+        return pipe(value, ...args);
+    }
+    $watch = (_properties, callback) => {
+        callback();
+        return {
+            unsubscribe: () => {
+            }
+        };
+    };
+    __getShadowRoot() {
+        return this._shadowRoot;
+    }
+    __getElement(id) {
+        return this._shadowRoot.querySelector(`[data-lid="${id}"]`);
+    }
+    isHTMLElement(el) {
+        return el !== null;
+    }
+    isPublisher(value) {
+        return typeof value === 'object' && value !== null && 'subscribe' in value && typeof value.subscribe === 'function';
+    }
+    isProperty(value) {
+        return typeof value === 'object' && value !== null && 'onChange' in value && 'setValue' in value;
+    }
+    __setText(id, text) {
+        const el = this.__getElement(id);
+        if (el)
+            el.textContent = text;
+    }
+    __bindText(id, getter) {
+        const el = this.__getElement(id);
+        if (!el)
+            return;
+        const expr = el.getAttribute('data-text-bind') ?? '';
+        const propMatch = /this\.([a-zA-Z_][a-zA-Z0-9_]*)/.exec(expr);
+        const update = () => {
+            try {
+                el.textContent = getter();
+            }
+            catch {
+                el.textContent = '';
+            }
+        };
+        if (propMatch) {
+            const [, propName] = propMatch;
+            const reactiveProp = this.__getReactiveProp(propName);
+            if (reactiveProp) {
+                this.__bindPropertyChange(reactiveProp, update);
+            }
+        }
+        update();
+    }
+    __setProperty(id, prop, value) {
+        const el = this.__getElement(id);
+        if (this.isHTMLElement(el)) {
+            if (prop in el) {
+                Reflect.set(el, prop, value);
+            }
+            else {
+                el.setAttribute(prop, String(value));
+            }
+        }
+    }
+    __addClass(id, className) {
+        const el = this.__getElement(id);
+        if (this.isHTMLElement(el))
+            el.classList.add(className);
+    }
+    __removeClass(id, className) {
+        const el = this.__getElement(id);
+        if (this.isHTMLElement(el))
+            el.classList.remove(className);
+    }
+    __bindEvent(id, event, handler) {
+        const el = this.__getElement(id);
+        if (el) {
+            el.addEventListener(event, handler);
+        }
+    }
+    __bindPropertyChange(prop, callback) {
+        const sub = prop.onChange.subscribe(callback);
+        this._subscriptions.push(sub);
+        const currentVal = prop.getValue();
+        if (currentVal !== null) {
+            callback(currentVal);
+        }
+    }
+    __connectProperties(source, target) {
+        const sub = source.onChange.subscribe((val) => {
+            target.setValue(val, true);
+        });
+        this._subscriptions.push(sub);
+        const currentVal = source.getValue();
+        if (currentVal !== null) {
+            target.setValue(currentVal, true);
+        }
+    }
+    __connectOutput(source, handler) {
+        const sub = source.subscribe(handler);
+        this._subscriptions.push(sub);
+    }
+    __bindOutput(id, outputName, handler) {
+        const el = this.__getElement(id);
+        if (el)
+            this.__bindOutputOnElement(el, outputName, handler);
+    }
+    __setChildProperty(el, propName, value) {
+        const prop = Reflect.get(el, propName);
+        if (this.isProperty(prop)) {
+            prop.setValue(value, true);
+        }
+        else if (propName in el) {
+            Reflect.set(el, propName, value);
+        }
+        else {
+            el.setAttribute(propName, String(value));
+        }
+    }
+    __bindToChild(id, propName, value) {
+        const el = this.__getElement(id);
+        if (!el)
+            return;
+        this.__setChildPropertyDeferred(el, propName, value);
+    }
+    __setChildPropertyDeferred(el, propName, value) {
+        if (Reflect.get(el, propName) !== undefined) {
+            this.__setChildProperty(el, propName, value);
+            return;
+        }
+        const tagName = el.tagName.toLowerCase();
+        if (tagName.includes('-')) {
+            customElements.whenDefined(tagName)
+                .then(() => {
+                this.__setChildProperty(el, propName, value);
+            })
+                .catch((e) => {
+                console.error(e);
+            });
+        }
+        else {
+            this.__setChildProperty(el, propName, value);
+        }
+    }
+    __bindOutputOnElement(el, outputName, handler) {
+        const maybeOutput = Reflect.get(el, outputName);
+        if (this.isPublisher(maybeOutput)) {
+            this.__connectOutput(maybeOutput, handler);
+            return;
+        }
+        const tagName = el.tagName.toLowerCase();
+        if (tagName.includes('-')) {
+            customElements.whenDefined(tagName)
+                .then(() => {
+                const innerOutput = Reflect.get(el, outputName);
+                if (this.isPublisher(innerOutput)) {
+                    this.__connectOutput(innerOutput, handler);
+                }
+                else {
+                    el.addEventListener(outputName, handler);
+                }
+            })
+                .catch((e) => {
+                console.error(e);
+            });
+        }
+        else {
+            el.addEventListener(outputName, handler);
+        }
+    }
+    __wireEvents(container, attrPrefix) {
+        for (const el of Array.from(container.querySelectorAll(`[${attrPrefix}]`))) {
+            const attr = el.getAttribute(attrPrefix);
+            if (!attr)
+                continue;
+            const eventParts = attrPrefix.split('-event-');
+            const [, eventPart] = eventParts;
+            if (!eventPart)
+                continue;
+            const [baseEvent, ...modifiers] = eventPart.split('-');
+            let handler = attr;
+            if (attr.startsWith('[')) {
+                try {
+                    const parsed = JSON.parse(attr);
+                    if (Array.isArray(parsed) && typeof parsed[1] === 'string') {
+                        [, handler] = parsed;
+                    }
+                }
+                catch {
+                }
+            }
+            el.addEventListener(baseEvent, (ev) => {
+                if (modifiers.length > 0 && ev instanceof KeyboardEvent) {
+                    const keyEv = ev;
+                    for (const mod of modifiers) {
+                        if (mod === 'enter' && keyEv.key !== 'Enter')
+                            return;
+                        if (mod === 'escape' && keyEv.key !== 'Escape')
+                            return;
+                        if (mod === 'space' && keyEv.key !== ' ')
+                            return;
+                    }
+                }
+                const refLookups = this.__buildRefLookups(handler);
+                // Dynamic event handlers are generated by the compiler from template attributes.
+                // The Function constructor is required to execute these at runtime.
+                // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-unsafe-type-assertion
+                const fn = Function('$event', refLookups + 'return this.' + handler)
+                    .bind(this);
+                fn(ev);
+            });
+        }
+    }
+    __buildRefLookups(expr) {
+        const shadow = this._shadowRoot;
+        const refEls = shadow.querySelectorAll('[data-ref]');
+        let code = '';
+        for (const el of Array.from(refEls)) {
+            const refName = el.getAttribute('data-ref');
+            if (refName && new RegExp(`\\b${refName}\\b`).test(expr)) {
+                code += `const ${refName} = this._shadowRoot.querySelector('[data-ref="${refName}"]');`;
+            }
+        }
+        return code;
+    }
+    __getReactiveProp(propName) {
+        const key = `__${propName}`;
+        if (key in this) {
+            const candidate = Reflect.get(this, key);
+            if (this.isProperty(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+}

package/utils/Property.d.ts

@@ -0,0 +1,16 @@
+import { Direction } from '../enums/Direction.js';
+import type { Subscription } from '../interfaces/Subscription.js';
+import { Publisher } from '../utils/Publisher.js';
+export declare class Property<T> {
+    readonly onChange: Publisher<T>;
+    readonly onInboundChange: Publisher<T>;
+    readonly onOutboundChange: Publisher<T>;
+    private value?;
+    private committed;
+    private _isChanging;
+    constructor(initialValue?: T);
+    setValue(val: T, inbound?: boolean, commit?: boolean): void;
+    triggerChange(direction?: Direction): Promise<void>;
+    subscribe(direction: Direction, cb: (val: T) => void): Subscription;
+    getValue(): T | null;
+}

package/utils/Property.js

@@ -0,0 +1,97 @@
+import { Direction } from '../enums/Direction.js';
+import { Publisher } from '../utils/Publisher.js';
+function safeStringify(obj) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (_key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) {
+                return '[Circular]';
+            }
+            seen.add(value);
+        }
+        return value;
+    });
+}
+export class Property {
+    onChange = new Publisher();
+    onInboundChange = new Publisher();
+    onOutboundChange = new Publisher();
+    value;
+    committed = true;
+    _isChanging = false;
+    constructor(initialValue) {
+        this.value = initialValue;
+    }
+    setValue(val, inbound = false, commit = true) {
+        if (this._isChanging) {
+            throw new Error('Binding loop detected: setValue called while change is in progress');
+        }
+        const changed = val !== this.value && safeStringify(val) !== safeStringify(this.value);
+        if (!changed)
+            return;
+        this._isChanging = true;
+        try {
+            this.value = val;
+            this.onChange.emit(val)
+                .catch((e) => {
+                console.error(e);
+            });
+            if (!commit) {
+                this.committed = false;
+            }
+            if (inbound) {
+                this.committed = true;
+                this.onInboundChange.emit(val)
+                    .catch((e) => {
+                    console.error(e);
+                });
+            }
+            else if (commit || !this.committed) {
+                this.committed = true;
+                if (this.value !== undefined) {
+                    this.onOutboundChange.emit(this.value)
+                        .catch((e) => {
+                        console.error(e);
+                    });
+                }
+            }
+        }
+        finally {
+            this._isChanging = false;
+        }
+    }
+    async triggerChange(direction = Direction.Any) {
+        if (this.value === undefined)
+            return;
+        await this.onChange.emit(this.value);
+        if (direction == Direction.Outbound) {
+            await this.onOutboundChange.emit(this.value);
+        }
+        if (direction == Direction.Inbound) {
+            await this.onOutboundChange.emit(this.value);
+        }
+    }
+    subscribe(direction, cb) {
+        if (direction == Direction.Inbound) {
+            return this.onInboundChange.subscribe((val) => {
+                cb(val);
+            });
+        }
+        else if (direction == Direction.Outbound) {
+            return this.onOutboundChange.subscribe((val) => {
+                cb(val);
+            });
+        }
+        else {
+            return this.onChange.subscribe((val) => {
+                cb(val);
+            });
+        }
+    }
+    getValue() {
+        if (this.value === undefined) {
+            return null;
+        }
+        return this.value;
+    }
+}

package/utils/Publisher.d.ts

@@ -0,0 +1,9 @@
+import type { Subscription } from '../interfaces/Subscription.js';
+type Callback<T> = (value: T) => void | Promise<void>;
+export declare class Publisher<T> {
+    private readonly callbacks;
+    emit(value: T): Promise<void>;
+    subscribe(callback: Callback<T>): Subscription;
+    subscribeOnce(callback: Callback<T>): Subscription;
+}
+export {};

package/utils/Publisher.js

@@ -0,0 +1,33 @@
+export class Publisher {
+    callbacks = new Set();
+    async emit(value) {
+        for (const callback of this.callbacks) {
+            try {
+                await callback(value);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    subscribe(callback) {
+        this.callbacks.add(callback);
+        return {
+            unsubscribe: () => {
+                this.callbacks.delete(callback);
+            },
+        };
+    }
+    subscribeOnce(callback) {
+        const wrappedCallback = async (value) => {
+            this.callbacks.delete(wrappedCallback);
+            await callback(value);
+        };
+        this.callbacks.add(wrappedCallback);
+        return {
+            unsubscribe: () => {
+                this.callbacks.delete(wrappedCallback);
+            },
+        };
+    }
+}