@buenojs/bueno 0.8.4 → 0.8.6

package/dist/container/index.js

@@ -0,0 +1,273 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/container/forward-ref.ts
+function forwardRef(fn) {
+  return {
+    __forwardRef: FORWARD_REF_SYMBOL,
+    forwardRef: fn
+  };
+}
+function isForwardRef(value) {
+  return typeof value === "object" && value !== null && "__forwardRef" in value && "forwardRef" in value && typeof value.forwardRef === "function";
+}
+function resolveForwardRef(ref) {
+  if (isForwardRef(ref)) {
+    return ref.forwardRef();
+  }
+  return ref;
+}
+var FORWARD_REF_SYMBOL;
+var init_forward_ref = __esm(() => {
+  FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
+});
+
+// src/container/index.ts
+var exports_container = {};
+__export(exports_container, {
+  setContainerMetadata: () => setContainerMetadata,
+  resolveForwardRef: () => resolveForwardRef,
+  isForwardRef: () => isForwardRef,
+  getInjectTokens: () => getContainerMetadata,
+  getContainerMetadata: () => getContainerMetadata,
+  forwardRef: () => forwardRef,
+  createToken: () => createToken,
+  Token: () => Token,
+  Injectable: () => Injectable,
+  Inject: () => Inject,
+  Container: () => Container
+});
+function createToken(description) {
+  return Symbol(description);
+}
+
+class ResolutionStack {
+  stack = new Set;
+  lazyResolutions = new Map;
+  push(token) {
+    if (this.stack.has(token)) {
+      throw new Error("Circular dependency detected: Token already in resolution stack");
+    }
+    this.stack.add(token);
+  }
+  pop(token) {
+    this.stack.delete(token);
+  }
+  has(token) {
+    return this.stack.has(token);
+  }
+  markLazy(token, placeholder) {
+    this.lazyResolutions.set(token, placeholder);
+  }
+  hasLazy(token) {
+    return this.lazyResolutions.has(token);
+  }
+  getLazy(token) {
+    return this.lazyResolutions.get(token);
+  }
+  clearLazy(token) {
+    this.lazyResolutions.delete(token);
+  }
+}
+
+class Container {
+  providers = new Map;
+  resolutionStack = new ResolutionStack;
+  register(provider) {
+    if (this.providers.has(provider.token)) {
+      throw new Error(`Provider already registered for token: ${String(provider.token)}`);
+    }
+    this.providers.set(provider.token, {
+      provider: {
+        ...provider,
+        scope: provider.scope ?? "singleton"
+      }
+    });
+  }
+  registerAll(providers) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+  has(token) {
+    return this.providers.has(token);
+  }
+  resolve(token) {
+    const resolved = this.providers.get(token);
+    if (!resolved) {
+      throw new Error(`No provider registered for token: ${String(token)}`);
+    }
+    const { provider } = resolved;
+    if (this.resolutionStack.has(token)) {
+      return this.createLazyProxy(token, resolved);
+    }
+    if (provider.scope === "singleton" && resolved.instance !== undefined) {
+      return resolved.instance;
+    }
+    this.resolutionStack.push(token);
+    try {
+      const instance = this.createInstance(provider);
+      if (provider.scope === "singleton") {
+        resolved.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.pop(token);
+    }
+  }
+  createLazyProxy(token, resolved) {
+    const existingLazy = this.resolutionStack.getLazy(token);
+    if (existingLazy && existingLazy.instance) {
+      return existingLazy.instance;
+    }
+    const placeholder = {
+      resolved: false
+    };
+    this.resolutionStack.markLazy(token, placeholder);
+    const proxy = new Proxy({}, {
+      get: (target, prop) => {
+        if (placeholder.resolved && placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        if (resolved.instance !== undefined) {
+          placeholder.instance = resolved.instance;
+          placeholder.resolved = true;
+        } else {
+          if (prop === "then") {
+            return;
+          }
+        }
+        if (placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        return () => {
+          return;
+        };
+      },
+      set: (target, prop, value) => {
+        if (placeholder.instance) {
+          placeholder.instance[prop] = value;
+          return true;
+        }
+        return false;
+      },
+      has: (target, prop) => {
+        if (placeholder.instance) {
+          return prop in placeholder.instance;
+        }
+        return false;
+      }
+    });
+    placeholder.instance = proxy;
+    return proxy;
+  }
+  createInstance(provider) {
+    if (provider.useValue !== undefined) {
+      return provider.useValue;
+    }
+    if (provider.useFactory) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return provider.useFactory(...deps);
+    }
+    if (provider.useClass) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return new provider.useClass(...deps);
+    }
+    throw new Error(`Invalid provider configuration for token: ${String(provider.token)}`);
+  }
+  resolveDeps(tokens) {
+    return tokens.map((tokenOrRef) => {
+      const token = resolveForwardRef(tokenOrRef);
+      return this.resolve(token);
+    });
+  }
+  clear() {
+    this.providers.clear();
+  }
+  getTokens() {
+    return Array.from(this.providers.keys());
+  }
+  createChild() {
+    const child = new Container;
+    for (const [token, resolved] of this.providers) {
+      if (resolved.provider.scope === "singleton") {
+        child.providers.set(token, resolved);
+      }
+    }
+    return child;
+  }
+}
+function setContainerMetadata(target, key, value) {
+  if (!containerMetadata.has(target)) {
+    containerMetadata.set(target, new Map);
+  }
+  containerMetadata.get(target)?.set(key, value);
+}
+function getContainerMetadata(target, key) {
+  return containerMetadata.get(target)?.get(key);
+}
+function Injectable(token) {
+  return (target) => {
+    setContainerMetadata(target, "injectable", true);
+    if (token) {
+      setContainerMetadata(target, "token", token);
+    }
+    return target;
+  };
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const targetObj = target;
+    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
+    existingTokens[parameterIndex] = token;
+    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+  };
+}
+var Token, containerMetadata;
+var init_container = __esm(() => {
+  init_forward_ref();
+  Token = createToken;
+  containerMetadata = new WeakMap;
+});
+init_container();
+
+export {
+  setContainerMetadata,
+  resolveForwardRef,
+  isForwardRef,
+  getContainerMetadata as getInjectTokens,
+  getContainerMetadata,
+  forwardRef,
+  createToken,
+  Token,
+  Injectable,
+  Inject,
+  Container
+};

package/dist/context/index.js

@@ -0,0 +1,219 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/context/index.ts
+var exports_context = {};
+__export(exports_context, {
+  createContext: () => createContext,
+  Context: () => Context
+});
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  for (const part of cookieHeader.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed) {
+      const [name, ...rest] = trimmed.split("=");
+      if (name && rest.length > 0) {
+        cookies[name.trim()] = rest.join("=").trim();
+      }
+    }
+  }
+  return cookies;
+}
+
+class Context {
+  req;
+  params;
+  query;
+  _cookies;
+  _bodyCache;
+  _response;
+  _variables = {};
+  constructor(request, params = {}) {
+    this.req = request;
+    this.params = params;
+    this.query = this.parseQuery(request.url);
+    this._response = {
+      status: 200,
+      headers: new Headers
+    };
+  }
+  get method() {
+    return this.req.method;
+  }
+  get url() {
+    return new URL(this.req.url);
+  }
+  get path() {
+    return this.url.pathname;
+  }
+  getHeader(name) {
+    return this.req.headers.get(name) ?? undefined;
+  }
+  getCookie(name) {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies[name];
+  }
+  get cookies() {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies;
+  }
+  async body() {
+    if (this._bodyCache !== undefined) {
+      return this._bodyCache;
+    }
+    const text = await this.req.text();
+    this._bodyCache = text ? JSON.parse(text) : null;
+    return this._bodyCache;
+  }
+  async parseBody() {
+    return this.body();
+  }
+  async bodyText() {
+    return this.req.text();
+  }
+  async bodyFormData() {
+    return this.req.formData();
+  }
+  async bodyArrayBuffer() {
+    return this.req.arrayBuffer();
+  }
+  async bodyBlob() {
+    return this.req.blob();
+  }
+  set(key, value) {
+    this._variables[key] = value;
+    return this;
+  }
+  get(key) {
+    return this._variables[key];
+  }
+  has(key) {
+    return key in this._variables;
+  }
+  status(code) {
+    this._response.status = code;
+    return this;
+  }
+  setHeader(name, value) {
+    this._response.headers.set(name, value);
+    return this;
+  }
+  appendHeader(name, value) {
+    this._response.headers.append(name, value);
+    return this;
+  }
+  json(data) {
+    this._response.headers.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  text(data) {
+    if (!this._response.headers.has("Content-Type")) {
+      this._response.headers.set("Content-Type", "text/plain");
+    }
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  html(data) {
+    this._response.headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url
+      }
+    });
+  }
+  notFound(message = "Not Found") {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  error(message, status = 500) {
+    return new Response(JSON.stringify({ error: message }), {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  newResponse(body, options) {
+    return new Response(body, {
+      status: this._response.status,
+      headers: this._response.headers,
+      ...options
+    });
+  }
+  parseQuery(url) {
+    const query = {};
+    const searchParams = new URL(url).searchParams;
+    for (const [key, value] of searchParams.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  accepts(...types) {
+    const acceptHeader = this.req.headers.get("Accept");
+    if (!acceptHeader)
+      return types[0];
+    for (const type of types) {
+      if (acceptHeader.includes(type) || acceptHeader.includes("*/*")) {
+        return type;
+      }
+    }
+    return;
+  }
+  get isXHR() {
+    return this.req.headers.get("X-Requested-With") === "XMLHttpRequest";
+  }
+  get ip() {
+    return this.req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? this.req.headers.get("x-real-ip") ?? undefined;
+  }
+}
+function createContext(request, params = {}) {
+  return new Context(request, params);
+}
+export {
+  createContext,
+  Context
+};