jiren 1.1.0 → 1.1.5

package/components/client-node.ts

@@ -1,105 +0,0 @@
-import type {
-  RequestOptions,
-  GetRequestOptions,
-  PostRequestOptions,
-  HttpResponse,
-} from "../types/index.js";
-
-/**
- * Node.js fallback client using native fetch
- */
-export class NodeJirenClient {
-  constructor() {
-    // No initialization needed for Node.js fetch
-  }
-
-  public close(): void {
-    // No cleanup needed
-  }
-
-  public async request(
-    url: string,
-    options: RequestOptions = {}
-  ): Promise<HttpResponse> {
-    const method = options.method || "GET";
-    const headers = options.headers || {};
-
-    const fetchOptions: RequestInit = {
-      method,
-      headers,
-      redirect:
-        options.maxRedirects && options.maxRedirects > 0 ? "follow" : "manual",
-    };
-
-    if (options.body) {
-      fetchOptions.body =
-        typeof options.body === "string"
-          ? options.body
-          : JSON.stringify(options.body);
-    }
-
-    try {
-      const response = await fetch(url, fetchOptions);
-      const body = await response.text();
-
-      // Convert Headers to plain object
-      const responseHeaders: Record<string, string> = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key.toLowerCase()] = value;
-      });
-
-      return {
-        status: response.status,
-        body,
-        headers: responseHeaders,
-        json: <T = any>() => {
-          if (!body) return null as T;
-          return JSON.parse(body) as T;
-        },
-      };
-    } catch (error) {
-      throw new Error(`HTTP request failed: ${error}`);
-    }
-  }
-
-  public async get(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "GET" });
-  }
-
-  public async post(
-    url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
-  ) {
-    return this.request(url, { ...options, method: "POST", body });
-  }
-
-  public async put(
-    url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
-  ) {
-    return this.request(url, { ...options, method: "PUT", body });
-  }
-
-  public async delete(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "DELETE" });
-  }
-
-  public async patch(
-    url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
-  ) {
-    return this.request(url, { ...options, method: "PATCH", body });
-  }
-
-  public async head(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "HEAD" });
-  }
-
-  public prefetch(urls: string[]) {
-    // No-op in Node.js
-    // Could implement DNS prefetch here if needed
-  }
-}

package/components/runtime.ts

@@ -1,11 +0,0 @@
-// Runtime detection
-export const isBun = typeof Bun !== "undefined";
-export const isNode = !isBun && typeof process !== "undefined";
-
-// Re-export types
-export type {
-  HttpResponse,
-  RequestOptions,
-  GetRequestOptions,
-  PostRequestOptions,
-} from "../types/index.js";

package/dist/index.js

@@ -1,271 +0,0 @@
-// @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 __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// components/native.ts
-import { dlopen, FFIType, suffix } from "bun:ffi";
-import { join } from "path";
-var libPath, ffiDef, lib;
-var init_native = __esm(() => {
-  libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
-  ffiDef = {
-    zclient_new: {
-      args: [],
-      returns: FFIType.ptr
-    },
-    zclient_free: {
-      args: [FFIType.ptr],
-      returns: FFIType.void
-    },
-    zclient_get: {
-      args: [FFIType.ptr, FFIType.cstring],
-      returns: FFIType.ptr
-    },
-    zclient_post: {
-      args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
-      returns: FFIType.ptr
-    },
-    zclient_prefetch: {
-      args: [FFIType.ptr, FFIType.cstring],
-      returns: FFIType.void
-    },
-    zclient_response_status: {
-      args: [FFIType.ptr],
-      returns: FFIType.u16
-    },
-    zclient_response_body: {
-      args: [FFIType.ptr],
-      returns: FFIType.ptr
-    },
-    zclient_response_body_len: {
-      args: [FFIType.ptr],
-      returns: FFIType.u64
-    },
-    zclient_response_headers: {
-      args: [FFIType.ptr],
-      returns: FFIType.ptr
-    },
-    zclient_response_headers_len: {
-      args: [FFIType.ptr],
-      returns: FFIType.u64
-    },
-    zclient_response_free: {
-      args: [FFIType.ptr],
-      returns: FFIType.void
-    },
-    zclient_request: {
-      args: [
-        FFIType.ptr,
-        FFIType.cstring,
-        FFIType.cstring,
-        FFIType.cstring,
-        FFIType.cstring
-      ],
-      returns: FFIType.ptr
-    }
-  };
-  lib = dlopen(libPath, ffiDef);
-});
-
-// components/client-bun.ts
-var exports_client_bun = {};
-__export(exports_client_bun, {
-  JirenClient: () => JirenClient
-});
-import { CString } from "bun:ffi";
-
-class JirenClient {
-  ptr;
-  constructor() {
-    this.ptr = lib.symbols.zclient_new();
-    if (!this.ptr)
-      throw new Error("Failed to create native client instance");
-  }
-  close() {
-    if (this.ptr) {
-      lib.symbols.zclient_free(this.ptr);
-      this.ptr = null;
-    }
-  }
-  request(url, options = {}) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    const method = options.method || "GET";
-    const methodBuffer = Buffer.from(method + "\x00");
-    const urlBuffer = Buffer.from(url + "\x00");
-    let headersBuffer = null;
-    if (options.headers) {
-      const headerStr = Object.entries(options.headers).map(([k, v]) => `${k.toLowerCase()}: ${v}`).join(`\r
-`);
-      if (headerStr.length > 0) {
-        headersBuffer = Buffer.from(headerStr + "\x00");
-      }
-    }
-    let bodyBuffer = null;
-    if (options.body) {
-      const bodyStr = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
-      bodyBuffer = Buffer.from(bodyStr + "\x00");
-    }
-    const respPtr = lib.symbols.zclient_request(this.ptr, methodBuffer, urlBuffer, headersBuffer, bodyBuffer);
-    const response = this.parseResponse(respPtr);
-    if (options.maxRedirects && options.maxRedirects > 0 && response.status >= 300 && response.status < 400 && response.headers && response.headers["location"]) {
-      const location = response.headers["location"];
-      const newUrl = new URL(location, url).toString();
-      const newOptions = { ...options, maxRedirects: options.maxRedirects - 1 };
-      return this.request(newUrl, newOptions);
-    }
-    return response;
-  }
-  get(url, options = {}) {
-    return this.request(url, { ...options, method: "GET" });
-  }
-  post(url, body, options = {}) {
-    return this.request(url, { ...options, method: "POST", body });
-  }
-  put(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PUT", body });
-  }
-  delete(url, options = {}) {
-    return this.request(url, { ...options, method: "DELETE" });
-  }
-  patch(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PATCH", body });
-  }
-  head(url, options = {}) {
-    return this.request(url, { ...options, method: "HEAD" });
-  }
-  prefetch(urls) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    for (const url of urls) {
-      const urlBuffer = Buffer.from(url + "\x00");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
-    }
-  }
-  parseResponse(respPtr) {
-    if (!respPtr)
-      throw new Error("Native request failed (returned null pointer)");
-    try {
-      const status = lib.symbols.zclient_response_status(respPtr);
-      const bodyLen = Number(lib.symbols.zclient_response_body_len(respPtr));
-      const bodyPtr = lib.symbols.zclient_response_body(respPtr);
-      const headersLen = Number(lib.symbols.zclient_response_headers_len(respPtr));
-      const headersPtr = lib.symbols.zclient_response_headers(respPtr);
-      let bodyString = "";
-      if (bodyLen > 0 && bodyPtr) {
-        bodyString = new CString(bodyPtr).toString();
-      }
-      const headers = {};
-      if (headersLen > 0 && headersPtr) {
-        const headersStr = new CString(headersPtr).toString();
-        const lines = headersStr.split(`\r
-`);
-        for (const line of lines) {
-          if (!line)
-            continue;
-          const colonIdx = line.indexOf(":");
-          if (colonIdx !== -1) {
-            const key = line.substring(0, colonIdx).trim().toLowerCase();
-            const val = line.substring(colonIdx + 1).trim();
-            headers[key] = val;
-          }
-        }
-      }
-      return {
-        status,
-        body: bodyString,
-        headers,
-        json: () => {
-          if (!bodyString)
-            return null;
-          return JSON.parse(bodyString);
-        }
-      };
-    } finally {
-      lib.symbols.zclient_response_free(respPtr);
-    }
-  }
-}
-var init_client_bun = __esm(() => {
-  init_native();
-});
-
-// components/client-node.ts
-var exports_client_node = {};
-__export(exports_client_node, {
-  NodeJirenClient: () => NodeJirenClient
-});
-
-class NodeJirenClient {
-  constructor() {}
-  close() {}
-  async request(url, options = {}) {
-    const method = options.method || "GET";
-    const headers = options.headers || {};
-    const fetchOptions = {
-      method,
-      headers,
-      redirect: options.maxRedirects && options.maxRedirects > 0 ? "follow" : "manual"
-    };
-    if (options.body) {
-      fetchOptions.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
-    }
-    try {
-      const response = await fetch(url, fetchOptions);
-      const body = await response.text();
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key.toLowerCase()] = value;
-      });
-      return {
-        status: response.status,
-        body,
-        headers: responseHeaders,
-        json: () => {
-          if (!body)
-            return null;
-          return JSON.parse(body);
-        }
-      };
-    } catch (error) {
-      throw new Error(`HTTP request failed: ${error}`);
-    }
-  }
-  async get(url, options = {}) {
-    return this.request(url, { ...options, method: "GET" });
-  }
-  async post(url, body, options = {}) {
-    return this.request(url, { ...options, method: "POST", body });
-  }
-  async put(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PUT", body });
-  }
-  async delete(url, options = {}) {
-    return this.request(url, { ...options, method: "DELETE" });
-  }
-  async patch(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PATCH", body });
-  }
-  async head(url, options = {}) {
-    return this.request(url, { ...options, method: "HEAD" });
-  }
-  prefetch(urls) {}
-}
-
-// components/runtime.ts
-var isBun = typeof Bun !== "undefined";
-
-// components/index.ts
-var JirenClient2 = isBun ? (await Promise.resolve().then(() => (init_client_bun(), exports_client_bun))).JirenClient : (await Promise.resolve().then(() => exports_client_node)).NodeJirenClient;
-export {
-  JirenClient2 as JirenClient
-};