@gramio/composer 0.1.0

package/dist/index.cjs

@@ -0,0 +1,520 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function compose(middlewares) {
+  if (middlewares.length === 0) {
+    return (_, next) => next ? next() : Promise.resolve();
+  }
+  return (context, next) => {
+    let lastIndex = -1;
+    function dispatch(i) {
+      if (i <= lastIndex) {
+        return Promise.reject(new Error("next() called multiple times"));
+      }
+      lastIndex = i;
+      const fn = i < middlewares.length ? middlewares[i] : next;
+      if (!fn) {
+        return Promise.resolve();
+      }
+      try {
+        return Promise.resolve(fn(context, () => dispatch(i + 1)));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    }
+    return dispatch(0);
+  };
+}
+
+function nameMiddleware(fn, type, handlerName) {
+  Object.defineProperty(fn, "name", {
+    value: handlerName ? `${type}:${handlerName}` : type,
+    configurable: true
+  });
+  return fn;
+}
+const LIB_DIR = /* @__PURE__ */ (() => {
+  try {
+    const url = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href));
+    const idx = url.lastIndexOf("/");
+    let dir = url.substring(0, idx);
+    if (dir.startsWith("file://")) {
+      dir = dir.slice(7);
+      if (/^\/[A-Za-z]:/.test(dir)) dir = dir.slice(1);
+    }
+    return dir;
+  } catch {
+    return "";
+  }
+})();
+function cleanErrorStack(error) {
+  if (!LIB_DIR || !(error instanceof Error) || !error.stack) return;
+  const fwd = LIB_DIR;
+  const bwd = LIB_DIR.replace(/\//g, "\\");
+  error.stack = error.stack.split("\n").filter((line) => {
+    if (!/^\s+at\s/.test(line)) return true;
+    return !line.includes(fwd) && !line.includes(bwd);
+  }).join("\n");
+}
+const noopNext = () => Promise.resolve();
+const skip = (_, next) => next();
+const stop = () => {
+};
+
+function resolveRouteHandler(handler) {
+  if (handler instanceof Composer) {
+    return compose(handler["~"].middlewares.map((m) => m.fn));
+  }
+  if (Array.isArray(handler)) {
+    return compose(handler);
+  }
+  return handler;
+}
+class Composer {
+  "~" = {
+    middlewares: [],
+    onErrors: [],
+    extended: /* @__PURE__ */ new Set(),
+    compiled: null,
+    name: void 0,
+    seed: void 0,
+    errorsDefinitions: {},
+    tracer: void 0
+  };
+  constructor(options) {
+    this["~"].name = options?.name;
+    this["~"].seed = options?.seed;
+  }
+  invalidate() {
+    this["~"].compiled = null;
+  }
+  decorate(values, options) {
+    const mw = (ctx, next) => {
+      Object.assign(ctx, values);
+      return next();
+    };
+    nameMiddleware(mw, "decorate");
+    const scope = options?.as ?? "local";
+    this["~"].middlewares.push({ fn: mw, scope, type: "decorate" });
+    this.invalidate();
+    return this;
+  }
+  use(...middleware) {
+    for (const fn of middleware) {
+      this["~"].middlewares.push({ fn, scope: "local", type: "use", name: fn.name || void 0 });
+    }
+    this.invalidate();
+    return this;
+  }
+  derive(handler, options) {
+    const handlerName = handler.name || void 0;
+    const mw = async (ctx, next) => {
+      const result = await handler(ctx);
+      Object.assign(ctx, result);
+      return next();
+    };
+    nameMiddleware(mw, "derive", handlerName);
+    const scope = options?.as ?? "local";
+    this["~"].middlewares.push({ fn: mw, scope, type: "derive", name: handlerName });
+    this.invalidate();
+    return this;
+  }
+  guard(predicate, ...middleware) {
+    const isGate = middleware.length === 0;
+    const predicateName = predicate.name || void 0;
+    if (isGate) {
+      const mw = async (ctx, next) => {
+        if (await predicate(ctx)) return next();
+      };
+      nameMiddleware(mw, "guard", predicateName);
+      this["~"].middlewares.push({ fn: mw, scope: "local", type: "guard", name: predicateName });
+    } else {
+      const chain = compose(middleware);
+      const mw = async (ctx, next) => {
+        if (await predicate(ctx)) {
+          await chain(ctx, noopNext);
+        }
+        await next();
+      };
+      nameMiddleware(mw, "guard", predicateName);
+      this["~"].middlewares.push({ fn: mw, scope: "local", type: "guard", name: predicateName });
+    }
+    this.invalidate();
+    return this;
+  }
+  branch(predicate, onTrue, onFalse) {
+    if (typeof predicate === "boolean") {
+      const branchName = predicate ? onTrue.name || void 0 : onFalse?.name || void 0;
+      if (predicate) {
+        this["~"].middlewares.push({ fn: onTrue, scope: "local", type: "branch", name: branchName });
+      } else if (onFalse) {
+        this["~"].middlewares.push({ fn: onFalse, scope: "local", type: "branch", name: branchName });
+      }
+      this.invalidate();
+      return this;
+    }
+    const predicateName = predicate.name || void 0;
+    const mw = async (ctx, next) => {
+      if (await predicate(ctx)) {
+        return onTrue(ctx, next);
+      }
+      return onFalse ? onFalse(ctx, next) : next();
+    };
+    nameMiddleware(mw, "branch", predicateName);
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "branch", name: predicateName });
+    this.invalidate();
+    return this;
+  }
+  route(router, casesOrBuilder, fallback) {
+    let resolvedCases;
+    let resolvedFallback;
+    if (typeof casesOrBuilder === "function") {
+      resolvedCases = {};
+      const composers = /* @__PURE__ */ new Map();
+      let otherwiseMws = [];
+      const routeBuilder = {
+        on: (key, ...middleware) => {
+          const c = new Composer();
+          if (middleware.length > 0) c.use(...middleware);
+          composers.set(key, c);
+          return c;
+        },
+        otherwise: (...middleware) => {
+          otherwiseMws = middleware;
+        }
+      };
+      casesOrBuilder(routeBuilder);
+      for (const [key, c] of composers) {
+        resolvedCases[key] = compose(c["~"].middlewares.map((m) => m.fn));
+      }
+      resolvedFallback = otherwiseMws.length > 0 ? compose(otherwiseMws) : void 0;
+    } else {
+      resolvedCases = {};
+      for (const [key, handler] of Object.entries(casesOrBuilder)) {
+        if (handler != null) {
+          resolvedCases[key] = resolveRouteHandler(handler);
+        }
+      }
+      resolvedFallback = fallback != null ? resolveRouteHandler(fallback) : void 0;
+    }
+    const routerName = router.name || void 0;
+    const mw = async (ctx, next) => {
+      const key = await router(ctx);
+      if (key != null) {
+        const caseHandler = resolvedCases[key];
+        if (caseHandler) return caseHandler(ctx, next);
+      }
+      return resolvedFallback ? resolvedFallback(ctx, next) : next();
+    };
+    nameMiddleware(mw, "route", routerName);
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "route", name: routerName });
+    this.invalidate();
+    return this;
+  }
+  fork(...middleware) {
+    const chain = compose(middleware);
+    const mw = (ctx, next) => {
+      Promise.resolve().then(() => {
+        try {
+          const result = chain(ctx, noopNext);
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+      });
+      return next();
+    };
+    nameMiddleware(mw, "fork");
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "fork" });
+    this.invalidate();
+    return this;
+  }
+  tap(...middleware) {
+    const chain = compose(middleware);
+    const mw = async (ctx, next) => {
+      await chain(ctx, noopNext);
+      return next();
+    };
+    nameMiddleware(mw, "tap");
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "tap" });
+    this.invalidate();
+    return this;
+  }
+  lazy(factory) {
+    const factoryName = factory.name || void 0;
+    const mw = async (ctx, next) => {
+      const resolved = await factory(ctx);
+      return resolved(ctx, next);
+    };
+    nameMiddleware(mw, "lazy", factoryName);
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "lazy", name: factoryName });
+    this.invalidate();
+    return this;
+  }
+  onError(handler) {
+    this["~"].onErrors.push(handler);
+    this.invalidate();
+    return this;
+  }
+  // ─── Conditional Registration ───
+  when(condition, fn) {
+    if (condition) {
+      const temp = new this.constructor();
+      fn(temp);
+      for (const mw of temp["~"].middlewares) {
+        this["~"].middlewares.push(mw);
+      }
+      Object.assign(this["~"].errorsDefinitions, temp["~"].errorsDefinitions);
+      this["~"].onErrors.push(...temp["~"].onErrors);
+      for (const key of temp["~"].extended) {
+        this["~"].extended.add(key);
+      }
+    }
+    this.invalidate();
+    return this;
+  }
+  // ─── Error Registration ───
+  error(kind, errorClass) {
+    this["~"].errorsDefinitions[kind] = errorClass;
+    return this;
+  }
+  // ─── Scope System ───
+  as(scope) {
+    for (const entry of this["~"].middlewares) {
+      if (scope === "global" || entry.scope === "local") {
+        entry.scope = scope;
+      }
+    }
+    this.invalidate();
+    return this;
+  }
+  // ─── Composition Methods ───
+  group(fn) {
+    const group = new Composer();
+    fn(group);
+    const chain = compose(group["~"].middlewares.map((m) => m.fn));
+    const mw = async (ctx, next) => {
+      const scopedCtx = Object.create(ctx);
+      await chain(scopedCtx, noopNext);
+      return next();
+    };
+    nameMiddleware(mw, "group");
+    this["~"].middlewares.push({ fn: mw, scope: "local", type: "group" });
+    this.invalidate();
+    return this;
+  }
+  extend(other) {
+    if (other["~"].name) {
+      const key = `${other["~"].name}:${JSON.stringify(other["~"].seed ?? null)}`;
+      if (this["~"].extended.has(key)) return this;
+      this["~"].extended.add(key);
+    }
+    for (const key of other["~"].extended) {
+      this["~"].extended.add(key);
+    }
+    Object.assign(this["~"].errorsDefinitions, other["~"].errorsDefinitions);
+    this["~"].onErrors.push(...other["~"].onErrors);
+    const pluginName = other["~"].name;
+    const localMws = other["~"].middlewares.filter((m) => m.scope === "local");
+    const scopedMws = other["~"].middlewares.filter((m) => m.scope === "scoped");
+    const globalMws = other["~"].middlewares.filter((m) => m.scope === "global");
+    if (localMws.length > 0) {
+      const chain = compose(localMws.map((m) => m.fn));
+      const isolated = async (ctx, next) => {
+        const scopedCtx = Object.create(ctx);
+        await chain(scopedCtx, noopNext);
+        return next();
+      };
+      nameMiddleware(isolated, "extend", pluginName);
+      this["~"].middlewares.push({ fn: isolated, scope: "local", type: "extend", name: pluginName, plugin: pluginName });
+    }
+    for (const mw of scopedMws) {
+      this["~"].middlewares.push({ fn: mw.fn, scope: "local", type: mw.type, name: mw.name, plugin: mw.plugin || pluginName });
+    }
+    for (const mw of globalMws) {
+      this["~"].middlewares.push({ fn: mw.fn, scope: "global", type: mw.type, name: mw.name, plugin: mw.plugin || pluginName });
+    }
+    this.invalidate();
+    return this;
+  }
+  inspect() {
+    return this["~"].middlewares.map((m, i) => {
+      const info = { index: i, type: m.type, scope: m.scope };
+      if (m.name) info.name = m.name;
+      if (m.plugin) info.plugin = m.plugin;
+      return info;
+    });
+  }
+  trace(handler) {
+    this["~"].tracer = handler;
+    this.invalidate();
+    return this;
+  }
+  compose() {
+    if (!this["~"].compiled) {
+      const mws = this["~"].middlewares;
+      const tracer = this["~"].tracer;
+      const fns = tracer ? mws.map((m, i) => {
+        const info = { index: i, type: m.type, scope: m.scope };
+        if (m.name) info.name = m.name;
+        if (m.plugin) info.plugin = m.plugin;
+        const orig = m.fn;
+        const traced = async (ctx, next) => {
+          const done = tracer(info, ctx);
+          try {
+            const result = await orig(ctx, next);
+            done?.();
+            return result;
+          } catch (err) {
+            done?.(err);
+            throw err;
+          }
+        };
+        nameMiddleware(traced, "traced", orig.name || m.name);
+        return traced;
+      }) : mws.map((m) => m.fn);
+      const chain = compose(fns);
+      const onErrors = this["~"].onErrors;
+      const errorsDefinitions = this["~"].errorsDefinitions;
+      this["~"].compiled = (async (ctx, next) => {
+        try {
+          return await chain(ctx, next);
+        } catch (error) {
+          cleanErrorStack(error);
+          let kind;
+          for (const [k, ErrorClass] of Object.entries(errorsDefinitions)) {
+            if (error instanceof ErrorClass) {
+              kind = k;
+              break;
+            }
+          }
+          for (const handler of onErrors) {
+            const result = await handler({ error, context: ctx, kind });
+            if (result !== void 0) return result;
+          }
+          console.error("[composer] Unhandled error:", error);
+        }
+      });
+    }
+    return this["~"].compiled;
+  }
+  run(context, next) {
+    return this.compose()(context, next ?? noopNext);
+  }
+}
+
+class EventQueue {
+  handler;
+  queue = [];
+  pendingUpdates = /* @__PURE__ */ new Set();
+  active = true;
+  idleResolvers = [];
+  constructor(handler) {
+    this.handler = handler;
+  }
+  add(event) {
+    this.queue.push(event);
+    this.process();
+  }
+  addBatch(events) {
+    this.queue.push(...events);
+    this.process();
+  }
+  async stop(timeout = 3e3) {
+    this.active = false;
+    await Promise.race([
+      this.onIdle(),
+      new Promise((resolve) => setTimeout(resolve, timeout))
+    ]);
+  }
+  onIdle() {
+    if (this.queue.length === 0 && this.pendingUpdates.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+  get pending() {
+    return this.pendingUpdates.size;
+  }
+  get queued() {
+    return this.queue.length;
+  }
+  get isActive() {
+    return this.active;
+  }
+  process() {
+    while (this.queue.length > 0 && this.active) {
+      const event = this.queue.shift();
+      const promise = this.handler(event).catch(() => {
+      }).then(() => {
+        this.pendingUpdates.delete(promise);
+        this.checkIdle();
+      });
+      this.pendingUpdates.add(promise);
+    }
+  }
+  checkIdle() {
+    if (this.queue.length === 0 && this.pendingUpdates.size === 0) {
+      for (const resolve of this.idleResolvers) {
+        resolve();
+      }
+      this.idleResolvers = [];
+    }
+  }
+}
+
+function createComposer(config) {
+  class EventComposerImpl extends Composer {
+    on(event, handler) {
+      const events = Array.isArray(event) ? event : [event];
+      const eventLabel = events.join("|");
+      const mw = (ctx, next) => {
+        if (events.includes(config.discriminator(ctx))) {
+          return handler(ctx, next);
+        }
+        return next();
+      };
+      nameMiddleware(mw, "on", eventLabel);
+      this["~"].middlewares.push({ fn: mw, scope: "local", type: "on", name: eventLabel });
+      this.invalidate();
+      return this;
+    }
+    derive(eventOrHandler, handlerOrOptions, maybeOptions) {
+      if (typeof eventOrHandler === "function") {
+        return super.derive(eventOrHandler, handlerOrOptions);
+      }
+      const events = Array.isArray(eventOrHandler) ? eventOrHandler : [eventOrHandler];
+      const handler = handlerOrOptions;
+      const eventLabel = events.join("|");
+      const handlerName = handler.name || void 0;
+      const deriveName = handlerName ? `${eventLabel}:${handlerName}` : eventLabel;
+      const mw = async (ctx, next) => {
+        if (events.includes(config.discriminator(ctx))) {
+          Object.assign(ctx, await handler(ctx));
+        }
+        return next();
+      };
+      nameMiddleware(mw, "derive", deriveName);
+      this["~"].middlewares.push({ fn: mw, scope: "local", type: "derive", name: deriveName });
+      this.invalidate();
+      return this;
+    }
+  }
+  return {
+    Composer: EventComposerImpl,
+    compose,
+    EventQueue
+  };
+}
+
+exports.Composer = Composer;
+exports.EventQueue = EventQueue;
+exports.compose = compose;
+exports.createComposer = createComposer;
+exports.noopNext = noopNext;
+exports.skip = skip;
+exports.stop = stop;