@psytask/core 1.0.0 → 1.1.0

package/README.md

@@ -0,0 +1 @@
+[PsyTask](https://github.com/bluebonesx/psytask) scene and event emitter model.

package/dist/index.d.ts

@@ -1,68 +1,116 @@
-type LooseObject = Record<string, any>;
-type Merge<T, U> = T extends any ? Omit<T, keyof U> & U : never;
+type LooseObject = Record<string, unknown>;
+type Merge<T, U> = T extends unknown ? Omit<T, keyof U> & U : never;
+type Split<T extends string, S extends string> = T extends unknown
+  ? T extends `${infer L}${S}${infer R}`
+    ? [L, ...Split<R, S>]
+    : [T]
+  : never;
+
+declare global {
+  interface ObjectConstructor {
+    keys<T>(o: T): (keyof T & string)[];
+  }
+  interface String {
+    split<T extends string, S extends string>(
+      this: T,
+      separator: S,
+    ): Split<T, S>;
+  }
+  interface Array<T> {
+    map<R>(fn: <E extends T>(e: E, i: number, arr: this) => R): R[];
+  }
+  interface Performance {
+    getEntriesByType(type: 'resource'): PerformanceResourceTiming[];
+  }
+}
 
 declare const symbol: typeof Symbol.dispose;
+type EventMap<T extends LooseObject> = T & {
+    dispose: undefined;
+};
 /** {@link Disposable} event emitter, use {@link Set} to manage listeners */
-declare class EventEmitter<M extends LooseObject & {
+declare class EventEmitter<T extends LooseObject & {
     dispose?: never;
-} = {}, EventMap extends {
-    dispose: null;
-} = M & {
-    dispose: null;
-}> implements Disposable {
+} = {}> implements Disposable {
     readonly listeners: {
-        readonly [K in keyof EventMap]?: Set<(e: EventMap[K]) => void>;
+        [K in keyof EventMap<T>]?: Set<(e: EventMap<T>[K]) => void>;
     };
     [symbol](): void;
     /** Add event listener */
-    on<K extends keyof EventMap>(type: K, listener: (evt: EventMap[K]) => void): this;
+    on<K extends keyof EventMap<T>>(type: K, listener: (evt: EventMap<T>[K]) => void): this;
     /** Remove event listener */
-    off<K extends keyof EventMap>(type: K, listener: (evt: EventMap[K]) => void): this;
+    off<K extends keyof EventMap<T>>(type: K, listener: (evt: EventMap<T>[K]) => void): this;
     /** Add one-time event listener, can not be removed manually */
-    once<K extends keyof EventMap>(type: K, listener: (evt: EventMap[K]) => void): this;
+    once<K extends keyof EventMap<T>>(type: K, listener: (evt: EventMap<T>[K]) => void): this;
     /** Emit event listeners */
-    emit<K extends keyof EventMap>(type: K, e: EventMap[K]): this;
+    emit<K extends keyof EventMap<T>>(type: K, ...[evt]: EventMap<T>[K] extends undefined ? [evt?: EventMap<T>[K]] : [evt: EventMap<T>[K]]): this;
 }
 
-declare const createShowInfo: () => {
-    start_time: number;
-    frame_times: number[];
+type TimerRecords = number[];
+type Timer = {
+    start(onFrame?: (records: TimerRecords) => void): Promise<TimerRecords>;
+    stop(): void;
 };
-type SceneShowInfo = ReturnType<typeof createShowInfo>;
-type ForbiddenSceneData = {
-    [K in keyof SceneShowInfo]?: never;
+/**
+ * ## Render logic
+ *
+ * ```text
+ * rAF(scene_1.show) -> render -> vsync -> rAF[scene_1.start_time] -> ... ->
+ * rAF(scene_2.show) -> ...
+ * ```
+ *
+ * ## Closing condition
+ *
+ * |    symbol/expression    | description         |
+ * | :---------------------: | ------------------- |
+ * |            t            | current frame time  |
+ * |           t_0           | start frame time    |
+ * |            D            | duration            |
+ * |         \delta          | next frame duration |
+ * |     e = t - t_0 - D     | duration error      |
+ * | \|e\| <= \|e + \delta\| | closing condition   |
+ *
+ * Inference:
+ *
+ * ```text
+ * For |e| <= |e + \delta|, given that \delta > 0
+ * if e >= 0 then e <= e + \delta -> true
+ * if e < 0 then -e <= |e + \delta|
+ *     if e + \delta >= 0 then -e <= e + \delta -> e >= -\delta / 2
+ *     if e + \delta < 0 then -e <= -e - \delta -> false
+ * ```
+ */
+declare const createTimer: (shouldStop: (records: TimerRecords) => boolean) => Timer;
+type NodeLike = string | Node;
+type BuiltinData = {
+    frame_times: TimerRecords;
 };
-type SceneTimerCreator = (options: {
-    frame_ms: number;
-    duration?: number;
-    onStart: (time: number) => void;
-    onFrame: (time: number) => void;
-}) => {
-    promise: Promise<void>;
-    close: () => void;
+type ForbiddenData = {
+    [K in keyof BuiltinData]?: never;
 };
-type NodeLike = string | Node;
 /**
- * Scene setup function, only called once when the scene is created.
+ * Only called once when the scene is created.
  *
  * @param props - The reactive props to control the scene display
- * @param ctx - The scene instance, can be used to manage lifecycle
  * @see {@link Scene}
  */
-type SceneSetup<P extends LooseObject = any, D extends LooseObject = LooseObject & ForbiddenSceneData> = (props: P, ctx: Scene<any>) => NodeLike | NodeLike[] | {
-    /** The node(s) appended to the root element of scene */
-    node: NodeLike | NodeLike[];
-    /** Data getter to get data from elements */
-    data: () => D;
+type Component<P extends LooseObject = any, D extends LooseObject = LooseObject & ForbiddenData> = {
+    (props: P): NodeLike | NodeLike[] | {
+        /** The node(s) appended to the root element of scene */
+        node: NodeLike | NodeLike[];
+        /** Data getter to get data from elements */
+        data: () => D;
+    };
 };
-type SceneShow<P extends LooseObject = any, D extends LooseObject = LooseObject & ForbiddenSceneData> = (patchProps?: Partial<P>) => Promise<Merge<D, SceneShowInfo>>;
-type GenericSceneSetup<P extends LooseObject = any, D extends LooseObject = LooseObject & ForbiddenSceneData> = SceneShow<P, D>;
+type SceneShow<P extends LooseObject = LooseObject, D extends LooseObject = LooseObject & ForbiddenData> = (patchProps?: Partial<P>) => Promise<Merge<D, BuiltinData>>;
+/** Same with {@link SceneShow} */
+type GenericComponent<P extends LooseObject = LooseObject, D extends LooseObject = LooseObject & ForbiddenData> = SceneShow<P, D>;
 /**
- * Provide type infer for generic setup function, do nothing in runtime.
+ * Provide type infer for generic component, do nothing in runtime.
  *
  * @example
  *
- * Support generic scene setup function
+ * Support generic component
  *
  * ```ts
  * using scene = new Scene(
@@ -74,128 +122,126 @@ type GenericSceneSetup<P extends LooseObject = any, D extends LooseObject = Loos
  * ```
  */
 declare const generic: {
-    <P extends LooseObject, D extends LooseObject & ForbiddenSceneData = {}>(f: SceneSetup<P, D>): GenericSceneSetup<P, D>;
+    <P extends LooseObject, D extends LooseObject & ForbiddenData = {}>(f: Component<P, D>): GenericComponent<P, D>;
 };
 /** @ignore */
-type MaybeGenericSceneSetup = SceneSetup | GenericSceneSetup;
+type MaybeGenericComponent<P extends LooseObject = any, D extends LooseObject & ForbiddenData = {}> = Component<P, D> | GenericComponent<P, D>;
+type ComponentAdapter = {
+    /** Wrap a component with reactive props */
+    wrap: <T extends Component>(component: T) => T;
+    /** Render a component with default props and provided scene */
+    render: <T extends Component>(component: T, defaultProps: Parameters<T>[0], 
+    /** If not provided, it will use current scene */
+    ctx?: Scene<Component>) => {
+        props: Parameters<T>[0];
+    } & (ReturnType<T> extends infer R ? R extends {
+        node: infer N;
+        data: infer D;
+    } ? {
+        nodes: N extends NodeLike ? [N] : N;
+        data: D;
+    } : {
+        nodes: R extends NodeLike ? [R] : R;
+        data: undefined;
+    } : never);
+};
+declare const createComponentAdapter: (reactive: <T extends LooseObject>(obj: T) => T) => ComponentAdapter;
 /**
- * Scene lifecycle and root element event name-value pairs.
+ * Lifecycle hooks.
  *
- * | name                  | trigger timing                                                                                           |
- * | --------------------- | -------------------------------------------------------------------------------------------------------- |
- * | scene:show            | the scene is shown                                                                                       |
- * | scene:frame           | on each frame when the scene is shown                                                                    |
- * | scene:close           | the scene is closed                                                                                      |
- * | mouse:left            | the left mouse button is pressed                                                                         |
- * | mouse:middle          | the middle mouse button is pressed                                                                       |
- * | mouse:right           | the right mouse button is pressed                                                                        |
- * | mouse:unknown         | an unknown mouse button is pressed                                                                       |
- * | key:\<key\>           | a {@link https://developer.mozilla.org/docs/Web/API/UI_Events/Keyboard_event_key_values key} is pressed  |
- * | \<HTMLElement-Event\> | an {@link https://developer.mozilla.org/docs/Web/API/HTMLElement#events html element event} is triggered |
+ * | name  | trigger timing                        |
+ * | ----- | ------------------------------------- |
+ * | show  | the scene is shown                    |
+ * | frame | on each frame when the scene is shown |
+ * | close | the scene is closed                   |
  */
-type SceneEventMap = HTMLElementEventMap & {
-    'scene:show': LooseObject;
-    'scene:frame': number;
-    'scene:close': null;
-} & {
-    [K in `mouse:${'left' | 'middle' | 'right' | 'unknown'}`]: MouseEvent;
-} & {
-    [K in `key:${string}`]: KeyboardEvent;
+type SceneEventMap = {
+    show: undefined;
+    frame: number;
+    close: undefined;
 };
+/**
+ * @example
+ *
+ * Must be called on the top scope of component
+ *
+ * ```ts
+ * const Component = (props: {}) => {
+ *   const ctx = getCurrentScene();
+ *   return '';
+ * };
+ * ```
+ *
+ * DO NOT call on other place
+ *
+ * ```ts
+ * const Component = (props: {}) => {
+ *   const fn = () => {
+ *     const ctx = getCurrentScene(); // WRONG!
+ *   };
+ *   return '';
+ * };
+ * ```
+ */
+declare const getCurrentScene: () => Scene<MaybeGenericComponent<any, {}>>;
 /** Scene options */
-type SceneOptions<T extends MaybeGenericSceneSetup> = {
+type SceneOptions<T extends MaybeGenericComponent> = {
     /** Root element */
     root: HTMLDivElement;
-    /** Frame duration in milliseconds */
-    frame_ms: number;
     /** Default props */
     defaultProps: Parameters<T>[0];
-    /** Scene duration in milliseconds */
-    duration?: number;
-    /** Close on specific {@link SceneEventMap events} */
-    close_on?: keyof SceneEventMap | (keyof SceneEventMap)[];
-    /** Whether to record frame times */
-    record_frame_times?: boolean;
-    /** Control display timing */
-    createTimer?: SceneTimerCreator;
+    /** Control show timing */
+    timer: () => Timer;
+    /** Component adapter */
+    adapter: ComponentAdapter;
 };
-declare class Scene<T extends MaybeGenericSceneSetup> extends EventEmitter<SceneEventMap> {
+declare class Scene<T extends MaybeGenericComponent> extends EventEmitter<SceneEventMap> {
     #private;
-    /** Root element */
+    readonly options: SceneOptions<T>;
     readonly root: HTMLDivElement;
+    readonly data: T extends MaybeGenericComponent<infer P, infer D> ? () => D : undefined;
     /**
-     * Show the scene and change props one-time
+     * Show DOM and update props one-time
      *
      * @example
      *
-     * Basic usage
+     * Integrate with `@vue/reactivity`
      *
      * ```ts
+     * import { reactive, effect } from '@vue/reactivity';
+     *
      * using scene = new Scene(
-     *   (props: { text: string }, ctx) => {
+     *   (props: { text: string }) => {
      *     const node = document.createElement('div');
-     *     ctx.on('scene:show', (newProps) => {
-     *       node.textContent = newProps.text;
+     *     effect(() => {
+     *       node.textContent = props.text; // auto update when props.text changes
      *     });
      *     return node;
      *   },
      *   {
-     *     //...
+     *     root: document.createElement('div'),
      *     defaultProps: { text: 'default' },
+     *     adapter: createComponentAdapter(reactive),
+     *     timer: () => createTimer((records) => records.length > 100), // show 100 frames
      *   },
      * );
+     * document.body.appendChild(scene.root);
+     *
      * await scene.show({ text: 'new' }); // show `new`
      * await scene.show(); // show `default`
      * ```
      *
      * @function
      */
-    show: T extends SceneSetup<infer P, infer D> ? SceneShow<P, D> : T;
+    show: T extends Component<infer P, infer D> ? SceneShow<P, D> : T;
     /**
-     * @param setup - The {@link SceneSetup scene setup function}
-     * @param defaultOptions - Default {@link SceneOptions scene options}
+     * @param component - {@link Component}
+     * @param options - {@link SceneOptions}
      */
-    constructor(setup: T, defaultOptions: SceneOptions<T>);
-    /**
-     * Override default options one-time
-     *
-     * @example
-     *
-     * Change duration temporarily
-     *
-     * ```ts
-     * using scene = new Scene(() => '', {
-     *   root: document.appendChild(document.createElement('div')),
-     *   frame_ms: 16.67,
-     *   defaultProps: {},
-     *   duration: 100,
-     * });
-     * await scene.config({ duration: 200 }).show(); // show 200ms
-     * await scene.show(); // show 100ms
-     * ```
-     */
-    config(patchOptions: {
-        [K in {
-            [K in keyof SceneOptions<T>]-?: undefined extends SceneOptions<T>[K] ? K : never;
-        }[keyof SceneOptions<T>]]?: SceneOptions<T>[K];
-    }): this;
-    /** Add a microtask to close the scene. It is useful when close in 'scene:show' */
+    constructor(component: T, options: SceneOptions<T>);
+    /** Add a microtask to close the scene. It is useful when close in 'show' */
     close(): Promise<void>;
 }
 
-type EventType<T extends EventTarget, U = keyof T> = U extends `on${infer K}` ? K : never;
-/**
- * Add event listener and return cleanup function
- *
- * @example
- *
- * Listen to window resize event
- *
- * ```ts
- * const cleanup = on(window, 'resize', (e) => {});
- * ```
- */
-declare const on: <T extends EventTarget, K extends EventType<T>>(target: T, type: K, listener: (ev: `on${K}` extends infer P extends Extract<keyof T, string> ? T[P] & {} extends infer F extends (...args: any) => any ? Parameters<F>[0] : never : never) => void, options?: boolean | AddEventListenerOptions) => () => void;
-
-export { EventEmitter, Scene, generic, on };
-export type { MaybeGenericSceneSetup, NodeLike, SceneEventMap, SceneOptions, SceneSetup, SceneTimerCreator };
+export { EventEmitter, Scene, createComponentAdapter, createTimer, generic, getCurrentScene };
+export type { Component, ComponentAdapter, MaybeGenericComponent, NodeLike, SceneEventMap, SceneOptions, Timer, TimerRecords };

package/dist/index.js

@@ -1,17 +1,16 @@
-/** @psytask/core v1.0.0 cubxx MIT */
-
-// src/event-emitter.ts
-var symbol = Symbol.dispose ?? Symbol.for("Symbol.dispose");
-
+/** @psytask/core v1.1.0 cubxx MIT */
+const symbol = Symbol.dispose ?? /* @__PURE__ */ Symbol.for("Symbol.dispose");
 class EventEmitter {
   listeners = {};
   [symbol]() {
-    this.emit("dispose", null);
+    this.emit("dispose");
   }
+  /** Add event listener */
   on(type, listener) {
-    (this.listeners[type] ??= new Set).add(listener);
+    (this.listeners[type] ??= /* @__PURE__ */ new Set()).add(listener);
     return this;
   }
+  /** Remove event listener */
   off(type, listener) {
     const listeners = this.listeners[type];
     if (listeners) {
@@ -20,6 +19,7 @@ class EventEmitter {
     }
     return this;
   }
+  /** Add one-time event listener, can not be removed manually */
   once(type, listener) {
     const wrapper = (evt) => {
       try {
@@ -31,113 +31,147 @@ class EventEmitter {
     this.on(type, wrapper);
     return this;
   }
-  emit(type, e) {
+  /** Emit event listeners */
+  emit(type, ...[evt]) {
     const listeners = this.listeners[type];
-    if (listeners)
-      for (const listener of [...listeners])
-        listener(e);
+    if (listeners) for (const listener of [...listeners]) listener(evt);
     return this;
   }
 }
-// ../../shared/utils.ts
-var ERR = (msg) => {
+
+const ERR = (msg) => {
   throw Error(msg);
 };
-var rAF = requestAnimationFrame;
-var array_normalize = (e) => Array.isArray(e) ? e : [e];
-
-// src/utils.ts
-var on = (target, type, listener, options) => (target.addEventListener(type, listener, options), () => target.removeEventListener(type, listener, options));
+const rAF = requestAnimationFrame;
+const $Object = Object;
+const modify = (a, b) => $Object.assign(a, b);
+const doc = document;
+new Proxy(
+  {},
+  {
+    get: (_, tag) => (props) => modify(doc.createElement(tag), props)
+  }
+);
+const array_normalize = (e) => Array.isArray(e) ? e : [e];
 
-// src/scene.ts
-var createShowInfo = () => ({ start_time: NaN, frame_times: [] });
-var createRAFTimer = (opts) => {
-  let start_time, close;
-  const frame = (last_time) => (opts.onFrame(last_time), typeof opts.duration === "number" && last_time - start_time >= opts.duration - opts.frame_ms * 1.5 ? close() : handle = rAF(frame));
-  let handle = rAF((last_time) => (opts.onStart(last_time), frame(start_time = last_time)));
-  return {
-    promise: new Promise((resolve) => close = () => (cancelAnimationFrame(handle), resolve())),
-    close
+const createTimer = (shouldStop) => {
+  const timer = {
+    start: (cb) => new Promise((resolve) => {
+      timer.stop = () => (cancelAnimationFrame(handle), resolve(records));
+      const records = [];
+      const frame = (time) => {
+        records.push(time);
+        cb?.(records);
+        shouldStop(records) ? timer.stop() : handle = rAF(frame);
+      };
+      let handle = rAF(frame);
+    }),
+    stop() {
+    }
   };
+  return timer;
 };
-var generic = (f) => f;
-var mouseSuffixs = ["left", "middle", "right"];
-var prefix2type = {
-  scene: 0,
-  dispose: 0,
-  key: "keydown",
-  mouse: "mousedown"
-};
-
+const generic = (f) => (
+  //@ts-expect-error impl generic component
+  f
+);
+const createComponentAdapter = (reactive) => ({
+  wrap: (component) => ((props) => component(reactive(props))),
+  render: (component, defaultProps, ctx) => {
+    const props = reactive(defaultProps);
+    ctx && sceneStack.push(ctx);
+    const instanceOrNode = component(props);
+    ctx && sceneStack.pop();
+    let data;
+    const nodes = array_normalize(
+      typeof instanceOrNode !== "string" && "node" in instanceOrNode ? (data = instanceOrNode.data, instanceOrNode.node) : instanceOrNode
+    );
+    return { props, nodes, data };
+  }
+});
+const sceneStack = [];
+const getCurrentScene = () => sceneStack[sceneStack.length - 1] ?? ERR("Not found current scene");
 class Scene extends EventEmitter {
-  root;
-  #data;
-  show = this.#show;
-  #options;
-  #defaultOptions;
-  #timer;
-  constructor(setup, defaultOptions) {
+  /**
+   * @param component - {@link Component}
+   * @param options - {@link SceneOptions}
+   */
+  constructor(component, options) {
     super();
-    const { root, defaultProps } = this.#defaultOptions = defaultOptions;
+    this.options = options;
+    const { root, adapter, defaultProps, timer } = options;
     (this.root = root).tabIndex = -1;
-    const reset = () => {
-      root.style.transform = "scale(0)";
-      this.#options = defaultOptions;
-      this.#timer = undefined;
-    };
-    reset();
-    const metaOrNode = setup(defaultProps, this.on("scene:close", reset).on("dispose", () => root.remove()));
-    root.append(...array_normalize(typeof metaOrNode === "object" && "node" in metaOrNode ? (this.#data = metaOrNode.data, metaOrNode.node) : metaOrNode));
-  }
-  config(patchOptions) {
-    this.#options = { ...this.#defaultOptions, ...patchOptions };
-    return this;
+    root.style.scale = "0";
+    const { props, nodes, data } = adapter.render(
+      component,
+      { ...defaultProps },
+      this.on("dispose", () => root.remove())
+    );
+    this.#timer = timer();
+    this.#props = props, this.data = data;
+    root.append(...nodes);
   }
+  root;
+  #timer;
+  #props;
+  data;
+  /**
+   * Show DOM and update props one-time
+   *
+   * @example
+   *
+   * Integrate with `@vue/reactivity`
+   *
+   * ```ts
+   * import { reactive, effect } from '@vue/reactivity';
+   *
+   * using scene = new Scene(
+   *   (props: { text: string }) => {
+   *     const node = document.createElement('div');
+   *     effect(() => {
+   *       node.textContent = props.text; // auto update when props.text changes
+   *     });
+   *     return node;
+   *   },
+   *   {
+   *     root: document.createElement('div'),
+   *     defaultProps: { text: 'default' },
+   *     adapter: createComponentAdapter(reactive),
+   *     timer: () => createTimer((records) => records.length > 100), // show 100 frames
+   *   },
+   * );
+   * document.body.appendChild(scene.root);
+   *
+   * await scene.show({ text: 'new' }); // show `new`
+   * await scene.show(); // show `default`
+   * ```
+   *
+   * @function
+   */
+  //@ts-expect-error impl generic component
+  show = this.#show;
+  /** Add a microtask to close the scene. It is useful when close in 'show' */
   async close() {
     await 0;
-    this.#timer?.close();
+    this.#timer.stop();
   }
-  async#show(patchProps) {
-    if (this.#timer)
-      ERR("Scene is showing");
-    const {
-      root,
-      frame_ms,
-      createTimer = createRAFTimer,
-      defaultProps,
-      duration,
-      close_on,
-      record_frame_times
-    } = this.#options;
-    this.emit("scene:show", { ...defaultProps, ...patchProps });
-    root.style.transform = "scale(1)";
+  async #show(patchProps) {
+    const { root, defaultProps } = this.options;
+    const newProps = { ...defaultProps, ...patchProps };
+    for (const key of Object.keys({ ...this.#props, ...newProps }))
+      this.#props[key] = newProps[key];
+    this.emit("show");
+    root.style.scale = "1";
     root.focus();
-    if (typeof close_on !== "undefined") {
-      const close = () => this.close();
-      array_normalize(close_on).map((type) => this.on(type, close).once("scene:close", () => this.off(type, close)));
-    }
-    let hasMouseType = 0, hasKeyType = 0;
-    const cleanups = Object.keys(this.listeners).map((type) => {
-      const DOM_type = prefix2type[type.split(":", 1)[0]] ?? type;
-      return DOM_type === "keydown" ? !hasKeyType++ && on(root, DOM_type, (e) => this.emit(`key:${e.key}`, e).emit(DOM_type, e)) : DOM_type === "mousedown" ? !hasMouseType++ && on(root, DOM_type, (e) => this.emit(`mouse:${mouseSuffixs[e.button] ?? "unknown"}`, e).emit(DOM_type, e)) : DOM_type && on(root, DOM_type, (e) => this.emit(type, e));
-    });
-    this.once("scene:close", () => cleanups.map((fn) => fn && fn()));
-    const showInfo = createShowInfo();
-    await (this.#timer = createTimer({
-      frame_ms,
-      duration,
-      onStart: (time) => showInfo.start_time = time,
-      onFrame: (time) => {
-        record_frame_times && showInfo.frame_times.push(time);
-        this.emit("scene:frame", time);
-      }
-    })).promise;
-    return { ...this.emit("scene:close", null).#data?.(), ...showInfo };
+    const records = await this.#timer.start(
+      (records2) => this.emit("frame", records2[records2.length - 1])
+    );
+    root.style.scale = "0";
+    return {
+      ...this.emit("close").data?.(),
+      frame_times: records
+    };
   }
 }
-export {
-  on,
-  generic,
-  Scene,
-  EventEmitter
-};
+
+export { EventEmitter, Scene, createComponentAdapter, createTimer, generic, getCurrentScene };

package/dist/index.min.js

@@ -1,2 +1 @@
-/** @psytask/core v1.0.0 cubxx MIT */
-var V=Symbol.dispose??Symbol.for("Symbol.dispose");class P{listeners={};[V](){this.emit("dispose",null)}on(T,c){return(this.listeners[T]??=new Set).add(c),this}off(T,c){let x=this.listeners[T];if(x)x.delete(c),x.size===0&&delete this.listeners[T];return this}once(T,c){let x=(k)=>{try{c(k)}finally{this.off(T,x)}};return this.on(T,x),this}emit(T,c){let x=this.listeners[T];if(x)for(let k of[...x])k(c);return this}}var A=(T)=>{throw Error(T)},r=requestAnimationFrame;var C=(T)=>Array.isArray(T)?T:[T];var E=(T,c,x,k)=>(T.addEventListener(c,x,k),()=>T.removeEventListener(c,x,k));var B=()=>({start_time:NaN,frame_times:[]}),F=(T)=>{let c,x,k=(b)=>(T.onFrame(b),typeof T.duration==="number"&&b-c>=T.duration-T.frame_ms*1.5?x():U=r(k)),U=r((b)=>(T.onStart(b),k(c=b)));return{promise:new Promise((b)=>x=()=>(cancelAnimationFrame(U),b())),close:x}},d=(T)=>T,G=["left","middle","right"],J={scene:0,dispose:0,key:"keydown",mouse:"mousedown"};class Q extends P{root;#c;show=this.#j;#x;#b;#T;constructor(T,c){super();let{root:x,defaultProps:k}=this.#b=c;(this.root=x).tabIndex=-1;let U=()=>{x.style.transform="scale(0)",this.#x=c,this.#T=void 0};U();let b=T(k,this.on("scene:close",U).on("dispose",()=>x.remove()));x.append(...C(typeof b==="object"&&"node"in b?(this.#c=b.data,b.node):b))}config(T){return this.#x={...this.#b,...T},this}async close(){await 0,this.#T?.close()}async#j(T){if(this.#T)A("Scene is showing");let{root:c,frame_ms:x,createTimer:k=F,defaultProps:U,duration:b,close_on:H,record_frame_times:L}=this.#x;if(this.emit("scene:show",{...U,...T}),c.style.transform="scale(1)",c.focus(),typeof H<"u"){let j=()=>this.close();C(H).map((K)=>this.on(K,j).once("scene:close",()=>this.off(K,j)))}let z=0,$=0,q=Object.keys(this.listeners).map((j)=>{let K=J[j.split(":",1)[0]]??j;return K==="keydown"?!$++&&E(c,K,(n)=>this.emit(`key:${n.key}`,n).emit(K,n)):K==="mousedown"?!z++&&E(c,K,(n)=>this.emit(`mouse:${G[n.button]??"unknown"}`,n).emit(K,n)):K&&E(c,K,(n)=>this.emit(j,n))});this.once("scene:close",()=>q.map((j)=>j&&j()));let g=B();return await(this.#T=k({frame_ms:x,duration:b,onStart:(j)=>g.start_time=j,onFrame:(j)=>{L&&g.frame_times.push(j),this.emit("scene:frame",j)}})).promise,{...this.emit("scene:close",null).#c?.(),...g}}}export{E as on,d as generic,Q as Scene,P as EventEmitter};
+const m=Symbol.dispose??Symbol.for("Symbol.dispose");class l{listeners={};[m](){this.emit("dispose")}on(t,s){return(this.listeners[t]??=new Set).add(s),this}off(t,s){const e=this.listeners[t];return e&&(e.delete(s),e.size===0&&delete this.listeners[t]),this}once(t,s){const e=n=>{try{s(n)}finally{this.off(t,e)}};return this.on(t,e),this}emit(t,...[s]){const e=this.listeners[t];if(e)for(const n of[...e])n(s);return this}}const f=o=>{throw Error(o)},h=requestAnimationFrame,u=Object,y=(o,t)=>u.assign(o,t),w=document;new Proxy({},{get:(o,t)=>s=>y(w.createElement(t),s)});const b=o=>Array.isArray(o)?o:[o],g=o=>{const t={start:s=>new Promise(e=>{t.stop=()=>(cancelAnimationFrame(r),e(n));const n=[],i=c=>{n.push(c),s?.(n),o(n)?t.stop():r=h(i)};let r=h(i)}),stop(){}};return t},S=o=>o,A=o=>({wrap:t=>(s=>t(o(s))),render:(t,s,e)=>{const n=o(s);e&&a.push(e);const i=t(n);e&&a.pop();let r;const c=b(typeof i!="string"&&"node"in i?(r=i.data,i.node):i);return{props:n,nodes:c,data:r}}}),a=[],E=()=>a[a.length-1]??f("Not found current scene");class P extends l{constructor(t,s){super(),this.options=s;const{root:e,adapter:n,defaultProps:i,timer:r}=s;(this.root=e).tabIndex=-1,e.style.scale="0";const{props:c,nodes:d,data:p}=n.render(t,{...i},this.on("dispose",()=>e.remove()));this.#t=r(),this.#s=c,this.data=p,e.append(...d)}root;#t;#s;data;show=this.#e;async close(){await 0,this.#t.stop()}async#e(t){const{root:s,defaultProps:e}=this.options,n={...e,...t};for(const r of Object.keys({...this.#s,...n}))this.#s[r]=n[r];this.emit("show"),s.style.scale="1",s.focus();const i=await this.#t.start(r=>this.emit("frame",r[r.length-1]));return s.style.scale="0",{...this.emit("close").data?.(),frame_times:i}}}export{l as EventEmitter,P as Scene,A as createComponentAdapter,g as createTimer,S as generic,E as getCurrentScene};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psytask/core",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "author": "cubxx",
   "license": "MIT",