@pisell/pisellos 0.0.5

package/lib/core/index.js

@@ -0,0 +1,212 @@
+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/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  PisellOSCore: () => PisellOSCore,
+  default: () => core_default
+});
+module.exports = __toCommonJS(core_exports);
+var import_createStore = require("../store/createStore");
+var import_effects = require("../effects");
+var PisellOSCore = class {
+  constructor(options) {
+    this.plugins = /* @__PURE__ */ new Map();
+    this.modules = /* @__PURE__ */ new Map();
+    this.stores = /* @__PURE__ */ new Map();
+    this.effects = new import_effects.EffectsManager();
+    this.debug = false;
+    this.context = {};
+    this.debug = (options == null ? void 0 : options.debug) || false;
+    this.context = (options == null ? void 0 : options.context) || {};
+    this.initialize(options);
+  }
+  initialize(options) {
+    if (options == null ? void 0 : options.plugins) {
+      options.plugins.forEach((item) => {
+        this.registerPlugin(item.plugin, item.options);
+      });
+    }
+    if (options == null ? void 0 : options.modules) {
+      options.modules.forEach((item) => {
+        this.registerModule(item.module, item.options);
+      });
+    }
+    this.log("PisellOS 核心初始化完成");
+  }
+  // 日志方法
+  log(message, level = "info") {
+    if (!this.debug && level === "info") {
+      return;
+    }
+    const prefix = "[PisellOS]";
+    switch (level) {
+      case "info":
+        console.log(`${prefix} ${message}`);
+        break;
+      case "warn":
+        console.warn(`${prefix} ${message}`);
+        break;
+      case "error":
+        console.error(`${prefix} ${message}`);
+        break;
+    }
+  }
+  // 插件相关方法
+  registerPlugin(plugin, options) {
+    if (this.plugins.has(plugin.name)) {
+      this.log(`插件 ${plugin.name} 已经注册过，将被覆盖`, "warn");
+    }
+    if (options == null ? void 0 : options.dependencies) {
+      for (const dep of options.dependencies) {
+        if (!this.plugins.has(dep)) {
+          throw new Error(`注册插件 ${plugin.name} 失败：缺少依赖插件 ${dep}`);
+        }
+      }
+    }
+    try {
+      const result = plugin.initialize();
+      if (result instanceof Promise) {
+        result.catch((err) => {
+          this.log(`插件 ${plugin.name} 初始化失败: ${err.message}`, "error");
+          throw err;
+        });
+      }
+      this.plugins.set(plugin.name, plugin);
+      this.log(`插件 ${plugin.name} v${plugin.version} 注册成功`);
+    } catch (error) {
+      this.log(`插件 ${plugin.name} 初始化过程中出错: ${error}`, "error");
+      throw error;
+    }
+  }
+  getPlugin(name) {
+    return this.plugins.get(name) || null;
+  }
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+  // 模块相关方法
+  registerModule(module2, options) {
+    if (this.modules.has(module2.name)) {
+      this.log(`模块 ${module2.name} 已经注册过，将被覆盖`, "warn");
+    }
+    if (options == null ? void 0 : options.dependencies) {
+      for (const dep of options.dependencies) {
+        if (!this.modules.has(dep)) {
+          throw new Error(`注册模块 ${module2.name} 失败：缺少依赖模块 ${dep}`);
+        }
+      }
+    }
+    if (options == null ? void 0 : options.plugins) {
+      for (const plugin of options.plugins) {
+        if (!this.plugins.has(plugin)) {
+          throw new Error(`注册模块 ${module2.name} 失败：缺少依赖插件 ${plugin}`);
+        }
+      }
+    }
+    const { proxy } = (0, import_createStore.createStore)(
+      (options == null ? void 0 : options.initialState) || {},
+      module2.name,
+      (path, value) => {
+        console.log("core 检测到模块值更新", module2.name, path, value);
+        this.effects.emit(`${module2.name}:changed`, value);
+        if (module2.storeChange)
+          module2.storeChange(path, value);
+      }
+    );
+    this.stores.set(module2.name, proxy);
+    try {
+      const result = module2.initialize(this, { store: proxy, ...options });
+      if (result instanceof Promise) {
+        result.catch((err) => {
+          this.log(`模块 ${module2.name} 初始化失败: ${err.message}`, "error");
+          throw err;
+        });
+      }
+      this.modules.set(module2.name, module2);
+      this.log(`模块 ${module2.name} v${module2.version} 注册成功`);
+    } catch (error) {
+      this.log(`模块 ${module2.name} 初始化过程中出错: ${error}`, "error");
+      throw error;
+    }
+  }
+  getModule(name) {
+    return this.modules.get(name) || null;
+  }
+  getModuleExports(name) {
+    const module2 = this.modules.get(name);
+    return (module2 == null ? void 0 : module2.exports) || null;
+  }
+  hasModule(name) {
+    return this.modules.has(name);
+  }
+  // 销毁方法
+  async destroy() {
+    for (const [name, module2] of this.modules.entries()) {
+      if (module2.destroy) {
+        try {
+          await Promise.resolve(module2.destroy());
+          this.log(`模块 ${name} 已销毁`);
+        } catch (error) {
+          this.log(`销毁模块 ${name} 时出错: ${error}`, "error");
+        }
+      }
+    }
+    this.modules.clear();
+    for (const [name, plugin] of this.plugins.entries()) {
+      if (plugin.destroy) {
+        try {
+          await Promise.resolve(plugin.destroy());
+          this.log(`插件 ${name} 已销毁`);
+        } catch (error) {
+          this.log(`销毁插件 ${name} 时出错: ${error}`, "error");
+        }
+      }
+    }
+    this.plugins.clear();
+    this.log("PisellOS 核心已销毁");
+  }
+  /**
+   * 验证上下文参数
+   */
+  validateContext(config) {
+    for (const rule of config.validations) {
+      const value = this.context[rule.name];
+      if (rule.required && (value === void 0 || value === null)) {
+        this.log(`模块 ${config.name} 缺少必需的上下文参数: ${rule.name}`, "error");
+        return false;
+      }
+      if (rule.validate && value !== void 0 && value !== null) {
+        if (!rule.validate(value)) {
+          this.log(
+            `模块 ${config.name} 上下文参数验证失败: ${rule.name} - ${rule.message || "验证失败"}`,
+            "error"
+          );
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+};
+var core_default = PisellOSCore;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PisellOSCore
+});

package/lib/effects/index.d.ts

@@ -0,0 +1,17 @@
+type EffectCallback = (payload: any) => void | Promise<void | {
+    status: boolean;
+    message?: string;
+}>;
+declare class EffectsManager {
+    private listeners;
+    on(event: string, callback: EffectCallback): void;
+    off(event: string, callback: EffectCallback): void;
+    offByModuleDestroy(module: string): void;
+    once(event: string, callback: EffectCallback): void;
+    emit(event: string, payload: any): Promise<{
+        status: boolean;
+        data: any;
+    }>;
+    clear(): void;
+}
+export { EffectsManager };

package/lib/effects/index.js

@@ -0,0 +1,78 @@
+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/effects/index.ts
+var effects_exports = {};
+__export(effects_exports, {
+  EffectsManager: () => EffectsManager
+});
+module.exports = __toCommonJS(effects_exports);
+var EffectsManager = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, callback) {
+    var _a;
+    if (!this.listeners.has(event))
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    (_a = this.listeners.get(event)) == null ? void 0 : _a.add(callback);
+  }
+  off(event, callback) {
+    var _a;
+    (_a = this.listeners.get(event)) == null ? void 0 : _a.delete(callback);
+  }
+  // 模块销毁时，删除所有以模块名开头的监听
+  offByModuleDestroy(module2) {
+    Array.from(this.listeners.keys()).forEach((item) => {
+      if (item.startsWith(module2)) {
+        this.listeners.delete(item);
+      }
+    });
+  }
+  once(event, callback) {
+    const wrapper = async (payload) => {
+      await callback(payload);
+      this.off(event, wrapper);
+    };
+    this.on(event, wrapper);
+  }
+  async emit(event, payload) {
+    const callbacks = this.listeners.get(event);
+    if (!callbacks)
+      return { status: true, data: [] };
+    return new Promise(async (resolve) => {
+      const res = [];
+      for (const cb of callbacks) {
+        const result = await cb(payload);
+        if (result !== void 0 && typeof result === "object" && "status" in result) {
+          res.push(result);
+        }
+      }
+      console.log(res);
+      const isAllPass = res.every((r) => (r == null ? void 0 : r.status) !== false);
+      resolve({ status: isAllPass, data: res });
+    });
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EffectsManager
+});

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PisellOS 前端SDK框架
+ * 提供可扩展的模块化架构，支持插件系统
+ */
+export * from './types';
+export * from './modules';
+export * from './plugins';
+export * from './solution';
+export { PisellOSCore } from './core';
+import PisellOSCore from './core';
+export default PisellOSCore;

package/lib/index.js

@@ -0,0 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PisellOSCore: () => import_core.PisellOSCore,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./modules"), module.exports);
+__reExport(src_exports, require("./plugins"), module.exports);
+__reExport(src_exports, require("./solution"), module.exports);
+var import_core = require("./core");
+var import_core2 = __toESM(require("./core"));
+var src_default = import_core2.default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PisellOSCore,
+  ...require("./types"),
+  ...require("./modules"),
+  ...require("./plugins"),
+  ...require("./solution")
+});

package/lib/modules/Account/index.d.ts

@@ -0,0 +1,21 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { BaseModule } from '../BaseModule';
+import { Account, AccountModuleAPI } from './types';
+export declare class AccountModule extends BaseModule implements Module, AccountModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private state;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    login(credentials: {
+        username: string;
+        password: string;
+    }): Promise<void>;
+    logout(): Promise<void>;
+    register(account: Omit<Account, 'id'>): Promise<void>;
+    getCurrentAccount(): Account | null;
+    updateProfile(updates: Partial<Account>): Promise<void>;
+    isLoggedIn(): boolean;
+    resetPassword(email: string): Promise<void>;
+    updatePassword(oldPassword: string, newPassword: string): Promise<void>;
+}

package/lib/modules/Account/index.js

@@ -0,0 +1,93 @@
+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/Account/index.ts
+var Account_exports = {};
+__export(Account_exports, {
+  AccountModule: () => AccountModule
+});
+module.exports = __toCommonJS(Account_exports);
+var import_BaseModule = require("../BaseModule");
+var import_types = require("./types");
+var AccountModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "account";
+    this.defaultVersion = "1.0.0";
+    this.state = {
+      currentAccount: null,
+      isLoggedIn: false
+    };
+  }
+  async initialize(core, options) {
+    this.core = core;
+    if (options == null ? void 0 : options.initialState) {
+      this.state = { ...this.state, ...options.initialState };
+    }
+  }
+  async login(credentials) {
+    const account = {
+      id: "1",
+      // 实际应该从 API 返回
+      username: credentials.username,
+      email: `${credentials.username}@example.com`,
+      name: credentials.username
+    };
+    this.state.currentAccount = account;
+    this.state.isLoggedIn = true;
+    await this.core.effects.emit(import_types.AccountHooks.OnLogin, account);
+  }
+  async logout() {
+    this.state.currentAccount = null;
+    this.state.isLoggedIn = false;
+    await this.core.effects.emit(import_types.AccountHooks.OnLogout, {});
+  }
+  async register(account) {
+    const newAccount = {
+      id: "1",
+      // 实际应该从 API 返回
+      ...account
+    };
+    this.state.currentAccount = newAccount;
+    this.state.isLoggedIn = true;
+    await this.core.effects.emit(import_types.AccountHooks.OnRegister, newAccount);
+  }
+  getCurrentAccount() {
+    return this.state.currentAccount;
+  }
+  async updateProfile(updates) {
+    if (!this.state.currentAccount)
+      return;
+    this.state.currentAccount = {
+      ...this.state.currentAccount,
+      ...updates
+    };
+    await this.core.effects.emit(import_types.AccountHooks.OnProfileUpdate, this.state.currentAccount);
+  }
+  isLoggedIn() {
+    return this.state.isLoggedIn;
+  }
+  async resetPassword(email) {
+  }
+  async updatePassword(oldPassword, newPassword) {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountModule
+});

package/lib/modules/Account/types.d.ts

@@ -0,0 +1,41 @@
+export declare enum AccountHooks {
+    OnLogin = "account:onLogin",
+    OnLogout = "account:onLogout",
+    OnRegister = "account:onRegister",
+    OnProfileUpdate = "account:onProfileUpdate"
+}
+/**
+ * 用户账户信息
+ */
+export interface Account {
+    id: string;
+    username: string;
+    email: string;
+    phone?: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * 账户模块状态
+ */
+export interface AccountState {
+    currentAccount: Account | null;
+    isLoggedIn: boolean;
+}
+/**
+ * 账户模块 API
+ */
+export interface AccountModuleAPI {
+    login: (credentials: {
+        username: string;
+        password: string;
+    }) => Promise<void>;
+    logout: () => Promise<void>;
+    register: (account: Omit<Account, 'id'>) => Promise<void>;
+    getCurrentAccount: () => Account | null;
+    updateProfile: (updates: Partial<Account>) => Promise<void>;
+    isLoggedIn: () => boolean;
+    resetPassword: (email: string) => Promise<void>;
+    updatePassword: (oldPassword: string, newPassword: string) => Promise<void>;
+}

package/lib/modules/Account/types.js

@@ -0,0 +1,35 @@
+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/Account/types.ts
+var types_exports = {};
+__export(types_exports, {
+  AccountHooks: () => AccountHooks
+});
+module.exports = __toCommonJS(types_exports);
+var AccountHooks = /* @__PURE__ */ ((AccountHooks2) => {
+  AccountHooks2["OnLogin"] = "account:onLogin";
+  AccountHooks2["OnLogout"] = "account:onLogout";
+  AccountHooks2["OnRegister"] = "account:onRegister";
+  AccountHooks2["OnProfileUpdate"] = "account:onProfileUpdate";
+  return AccountHooks2;
+})(AccountHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountHooks
+});

package/lib/modules/BaseModule.d.ts

@@ -0,0 +1,11 @@
+import { PisellCore } from "../types";
+export declare class BaseModule {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    name: string;
+    version: string;
+    isSolution: boolean;
+    protected core: PisellCore;
+    constructor(name?: string, version?: string);
+    destory(): void;
+}

package/lib/modules/BaseModule.js

@@ -0,0 +1,40 @@
+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/BaseModule.ts
+var BaseModule_exports = {};
+__export(BaseModule_exports, {
+  BaseModule: () => BaseModule
+});
+module.exports = __toCommonJS(BaseModule_exports);
+var BaseModule = class {
+  constructor(name, version) {
+    this.defaultName = "baseModule";
+    this.defaultVersion = "1.0.0";
+    this.isSolution = false;
+    this.name = name || this.defaultName;
+    this.version = version || this.defaultVersion;
+  }
+  destory() {
+    this.core.effects.offByModuleDestroy(this.name);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseModule
+});

package/lib/modules/Cart/index.d.ts

@@ -0,0 +1,33 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { BaseModule } from '../BaseModule';
+import { CartItem, CartModuleAPI } from './types';
+export * from './types';
+/**
+ * 购物车模块实现
+ */
+export declare class CartModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private window;
+    private store;
+    exports: CartModuleAPI;
+    constructor(name?: string, version?: string);
+    /**
+     * 初始化购物车模块
+     */
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    /**
+     * 模块销毁
+     */
+    destroy(): Promise<void>;
+    /**
+     * 添加商品到购物车
+     */
+    addItem(item: CartItem): Promise<void>;
+    getItemCount(): number;
+    getTotalPrice(): number;
+    getItems(): Promise<CartItem[]>;
+    updateItemQuantity(id: string, quantity: number): Promise<void>;
+    removeItem(id: string): Promise<void>;
+}