@pisell/pisellos 0.0.5

package/lib/modules/Resource/types.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Resource/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ResourceHooks: () => ResourceHooks
+});
+module.exports = __toCommonJS(types_exports);
+var ResourceHooks = /* @__PURE__ */ ((ResourceHooks2) => {
+  ResourceHooks2["OnResourceSelect"] = "resource:onResourceSelect";
+  ResourceHooks2["OnResourceChange"] = "resource:onResourceChange";
+  ResourceHooks2["OnAvailabilityCheck"] = "resource:onAvailabilityCheck";
+  return ResourceHooks2;
+})(ResourceHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceHooks
+});

package/lib/modules/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Product';
+export * from './ProductList';
+export * from './Cart';

package/lib/modules/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/index.ts
+var modules_exports = {};
+module.exports = __toCommonJS(modules_exports);
+__reExport(modules_exports, require("./Product"), module.exports);
+__reExport(modules_exports, require("./ProductList"), module.exports);
+__reExport(modules_exports, require("./Cart"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Product"),
+  ...require("./ProductList"),
+  ...require("./Cart")
+});

package/lib/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export * from './request';
+export * from './window';

package/lib/plugins/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/index.ts
+var plugins_exports = {};
+module.exports = __toCommonJS(plugins_exports);
+__reExport(plugins_exports, require("./request"), module.exports);
+__reExport(plugins_exports, require("./window"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./request"),
+  ...require("./window")
+});

package/lib/plugins/request.d.ts

@@ -0,0 +1,127 @@
+import { Plugin } from '../types';
+/**
+ * RequestPlugin 接口定义
+ */
+export interface RequestPlugin extends Plugin {
+    /**
+     * 发起 GET 请求
+     * @param url 请求地址
+     * @param options 请求选项
+     */
+    get: <T = any>(url: string, options?: RequestOptions) => Promise<T>;
+    /**
+     * 发起 POST 请求
+     * @param url 请求地址
+     * @param data 请求数据
+     * @param options 请求选项
+     */
+    post: <T = any>(url: string, data?: any, options?: RequestOptions) => Promise<T>;
+    /**
+     * 发起 PUT 请求
+     * @param url 请求地址
+     * @param data 请求数据
+     * @param options 请求选项
+     */
+    put: <T = any>(url: string, data?: any, options?: RequestOptions) => Promise<T>;
+    /**
+     * 发起 DELETE 请求
+     * @param url 请求地址
+     * @param options 请求选项
+     */
+    delete: <T = any>(url: string, options?: RequestOptions) => Promise<T>;
+    /**
+     * 通用请求方法
+     * @param options 完整的请求选项
+     */
+    request: <T = any>(options: RequestOptions) => Promise<T>;
+}
+/**
+ * 请求配置
+ */
+export interface RequestOptions {
+    url?: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    data?: any;
+    body?: any;
+    params?: Record<string, string | number | boolean>;
+    timeout?: number;
+    responseType?: 'json' | 'text' | 'arraybuffer' | 'blob';
+    withCredentials?: boolean;
+}
+/**
+ * 响应接口
+ */
+export interface Response<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: RequestOptions;
+}
+/**
+ * 请求错误
+ */
+export declare class RequestError extends Error {
+    response?: Response;
+    request?: any;
+    config?: RequestOptions;
+    constructor(message: string, config?: RequestOptions, request?: any, response?: Response);
+}
+/**
+ * RequestPlugin 实现
+ */
+declare class RequestPluginImpl implements RequestPlugin {
+    name: string;
+    version: string;
+    private core;
+    /**
+     * 默认请求选项
+     */
+    private defaultOptions;
+    /**
+     * 全局拦截器
+     */
+    private interceptors;
+    initialize(): void;
+    destroy(): void;
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor: (config: RequestOptions) => RequestOptions | Promise<RequestOptions>): void;
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor: (response: Response) => Response | Promise<Response>): void;
+    /**
+     * 添加错误拦截器
+     */
+    addErrorInterceptor(interceptor: (error: RequestError) => RequestError | Promise<RequestError>): void;
+    /**
+     * GET 请求
+     */
+    get<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    /**
+     * POST 请求
+     */
+    post<T = any>(url: string, data?: any, options?: RequestOptions): Promise<T>;
+    /**
+     * PUT 请求
+     */
+    put<T = any>(url: string, data?: any, options?: RequestOptions): Promise<T>;
+    /**
+     * DELETE 请求
+     */
+    delete<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    /**
+     * 通用请求方法
+     */
+    request<T = any>(options: RequestOptions): Promise<T>;
+    /**
+     * 执行实际的请求
+     * 这里实现了一个基于 fetch API 的请求
+     */
+    private performRequest;
+}
+declare const _default: RequestPluginImpl;
+export default _default;

package/lib/plugins/request.js

@@ -0,0 +1,297 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/request.ts
+var request_exports = {};
+__export(request_exports, {
+  RequestError: () => RequestError,
+  default: () => request_default
+});
+module.exports = __toCommonJS(request_exports);
+var RequestError = class extends Error {
+  constructor(message, config, request, response) {
+    super(message);
+    this.name = "RequestError";
+    this.config = config;
+    this.request = request;
+    this.response = response;
+  }
+};
+var RequestPluginImpl = class {
+  constructor() {
+    this.name = "request";
+    this.version = "1.0.0";
+    this.core = null;
+    /**
+     * 默认请求选项
+     */
+    this.defaultOptions = {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      timeout: 3e4,
+      responseType: "json"
+    };
+    /**
+     * 全局拦截器
+     */
+    this.interceptors = {
+      request: [],
+      response: [],
+      error: []
+    };
+  }
+  // 初始化方法
+  initialize() {
+    this.core = globalThis.pisellOS;
+    console.log("[RequestPlugin] 初始化完成");
+  }
+  // 销毁方法
+  destroy() {
+    console.log("[RequestPlugin] 已销毁");
+  }
+  /**
+   * 添加请求拦截器
+   */
+  addRequestInterceptor(interceptor) {
+    this.interceptors.request.push(interceptor);
+  }
+  /**
+   * 添加响应拦截器
+   */
+  addResponseInterceptor(interceptor) {
+    this.interceptors.response.push(interceptor);
+  }
+  /**
+   * 添加错误拦截器
+   */
+  addErrorInterceptor(interceptor) {
+    this.interceptors.error.push(interceptor);
+  }
+  /**
+   * GET 请求
+   */
+  get(url, options = {}) {
+    return this.request({
+      ...options,
+      url,
+      method: "GET"
+    });
+  }
+  /**
+   * POST 请求
+   */
+  post(url, data, options = {}) {
+    return this.request({
+      ...options,
+      url,
+      method: "POST",
+      data
+    });
+  }
+  /**
+   * PUT 请求
+   */
+  put(url, data, options = {}) {
+    return this.request({
+      ...options,
+      url,
+      method: "PUT",
+      data
+    });
+  }
+  /**
+   * DELETE 请求
+   */
+  delete(url, options = {}) {
+    return this.request({
+      ...options,
+      url,
+      method: "DELETE"
+    });
+  }
+  /**
+   * 通用请求方法
+   */
+  async request(options) {
+    let config = {
+      ...this.defaultOptions,
+      ...options,
+      headers: {
+        ...this.defaultOptions.headers,
+        ...options.headers
+      }
+    };
+    if (!config.headers["authorization"] && this.core) {
+      const windowPlugin = this.core.getPlugin("window");
+      if (windowPlugin) {
+        config.headers["authorization"] = windowPlugin.localStorage.getItem("token") || "";
+      }
+    }
+    for (const interceptor of this.interceptors.request) {
+      try {
+        config = await Promise.resolve(interceptor(config));
+      } catch (error) {
+        const requestError = error instanceof RequestError ? error : new RequestError(
+          error instanceof Error ? error.message : "请求拦截器错误",
+          config
+        );
+        let processedError = requestError;
+        for (const errorInterceptor of this.interceptors.error) {
+          try {
+            processedError = await Promise.resolve(errorInterceptor(processedError));
+          } catch (e) {
+          }
+        }
+        throw processedError;
+      }
+    }
+    try {
+      const response = await this.performRequest(config);
+      let processedResponse = response;
+      for (const interceptor of this.interceptors.response) {
+        try {
+          processedResponse = await Promise.resolve(interceptor(processedResponse));
+        } catch (error) {
+          const requestError = error instanceof RequestError ? error : new RequestError(
+            error instanceof Error ? error.message : "响应拦截器错误",
+            config,
+            null,
+            response
+          );
+          let processedError = requestError;
+          for (const errorInterceptor of this.interceptors.error) {
+            try {
+              processedError = await Promise.resolve(errorInterceptor(processedError));
+            } catch (e) {
+            }
+          }
+          throw processedError;
+        }
+      }
+      return processedResponse.data;
+    } catch (error) {
+      const requestError = error instanceof RequestError ? error : new RequestError(
+        error instanceof Error ? error.message : "请求错误",
+        config
+      );
+      let processedError = requestError;
+      for (const errorInterceptor of this.interceptors.error) {
+        try {
+          processedError = await Promise.resolve(errorInterceptor(processedError));
+        } catch (e) {
+        }
+      }
+      throw processedError;
+    }
+  }
+  /**
+   * 执行实际的请求
+   * 这里实现了一个基于 fetch API 的请求
+   */
+  async performRequest(config) {
+    const { url, method, headers, data, params, timeout, responseType, withCredentials } = config;
+    if (!url) {
+      throw new RequestError("URL不能为空", config);
+    }
+    let fullUrl = url;
+    if (params && Object.keys(params).length > 0) {
+      const queryString = Object.entries(params).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+      fullUrl += (url.includes("?") ? "&" : "?") + queryString;
+    }
+    const fetchOptions = {
+      method,
+      headers: {
+        ...headers
+      },
+      credentials: withCredentials ? "include" : "same-origin"
+    };
+    if (data !== void 0 && method !== "GET" && method !== "HEAD") {
+      if (data instanceof FormData) {
+        fetchOptions.body = data;
+        delete fetchOptions.headers["Content-Type"];
+      } else if (typeof data === "object") {
+        fetchOptions.body = JSON.stringify(data);
+      } else {
+        fetchOptions.body = data;
+      }
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          reject(new RequestError(`请求超时: ${timeout}ms`, config));
+        }, timeout);
+      }
+    });
+    try {
+      const fetchPromise = typeof fetch !== "undefined" ? fetch(fullUrl, fetchOptions) : Promise.reject(new RequestError("当前环境不支持 fetch API", config));
+      const response = await Promise.race([fetchPromise, timeoutPromise]);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      let responseData;
+      if (responseType === "json") {
+        try {
+          responseData = await response.json();
+        } catch (e) {
+          responseData = await response.text();
+        }
+      } else if (responseType === "text") {
+        responseData = await response.text();
+      } else if (responseType === "arraybuffer") {
+        responseData = await response.arrayBuffer();
+      } else if (responseType === "blob") {
+        responseData = await response.blob();
+      } else {
+        try {
+          responseData = await response.json();
+        } catch (e) {
+          responseData = await response.text();
+        }
+      }
+      const result = {
+        data: responseData,
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        config
+      };
+      if (!response.ok) {
+        throw new RequestError(
+          `请求失败，状态码: ${response.status}`,
+          config,
+          fetchOptions,
+          result
+        );
+      }
+      return result;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+};
+var request_default = new RequestPluginImpl();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestError
+});

package/lib/plugins/window.d.ts

@@ -0,0 +1,115 @@
+import { Plugin } from '../types';
+/**
+ * WindowPlugin 接口定义
+ */
+export interface WindowPlugin extends Plugin {
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    localStorage: Storage;
+    sessionStorage: Storage;
+    location: Partial<Location>;
+    navigator: Partial<Navigator>;
+    document: Partial<Document>;
+    history: History;
+}
+/**
+ * 简单的 Storage 接口实现
+ */
+declare class SimpleStorage implements Storage {
+    private items;
+    get length(): number;
+    key(index: number): string | null;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+}
+/**
+ * 简单的 Location 类实现
+ */
+declare class SimpleLocation implements Partial<Location> {
+    hash: string;
+    host: string;
+    hostname: string;
+    href: string;
+    origin: string;
+    pathname: string;
+    port: string;
+    protocol: string;
+    search: string;
+    ancestorOrigins: DOMStringList;
+    assign(url: string | URL): void;
+    reload(): void;
+    replace(url: string | URL): void;
+    toString(): string;
+}
+/**
+ * 简单的 Navigator 类实现
+ */
+declare class SimpleNavigator implements Partial<Navigator> {
+    userAgent: string;
+    language: string;
+    languages: string[];
+    onLine: boolean;
+    cookieEnabled: boolean;
+    readonly appCodeName: string;
+    readonly appName: string;
+    readonly appVersion: string;
+    readonly platform: string;
+    readonly product: string;
+    javaEnabled(): boolean;
+}
+/**
+ * 简单的 History 接口实现
+ */
+declare class SimpleHistory implements History {
+    length: number;
+    scrollRestoration: ScrollRestoration;
+    state: any;
+    back(): void;
+    forward(): void;
+    go(): void;
+    pushState(): void;
+    replaceState(): void;
+}
+/**
+ * 简单的 Document 类实现
+ */
+declare class SimpleDocument implements Partial<Document> {
+    private elements;
+    createElement(tagName: string): HTMLElement;
+    getElementById(id: string): HTMLElement | null;
+    readonly URL: string;
+    readonly documentURI: string;
+    readonly origin: string;
+    readonly characterSet: string;
+    readonly contentType: string;
+    readonly compatMode: string;
+    querySelector(): Element | null;
+    querySelectorAll(): NodeListOf<Element>;
+    getElementsByTagName(): HTMLCollectionOf<Element>;
+    getElementsByClassName(): HTMLCollectionOf<Element>;
+}
+/**
+ * Window 插件实现
+ */
+declare class WindowPluginImpl implements WindowPlugin {
+    name: string;
+    version: string;
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    localStorage: SimpleStorage;
+    sessionStorage: SimpleStorage;
+    location: SimpleLocation;
+    navigator: SimpleNavigator;
+    document: SimpleDocument;
+    history: SimpleHistory;
+    initialize(): void;
+    destroy(): void;
+}
+declare const _default: WindowPluginImpl;
+export default _default;