@pisell/pisellos 0.0.6 → 0.0.7

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

@@ -0,0 +1,18 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { AccountModule, Account } from '../Account';
+import { BaseModule } from '../BaseModule';
+import { AccountListState } from './types';
+export declare class AccountListModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    addAccount(account: Account): Promise<void>;
+    updateAccount(id: string, updates: Partial<Account>): Promise<void>;
+    removeAccount(id: string): Promise<void>;
+    getAccounts(): AccountModule[];
+    getAccount(id: string): AccountModule | null;
+    clearAccounts(): Promise<void>;
+    getState(): AccountListState;
+}

package/lib/modules/AccountList/index.js

@@ -0,0 +1,126 @@
+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/AccountList/index.ts
+var AccountList_exports = {};
+__export(AccountList_exports, {
+  AccountListModule: () => AccountListModule
+});
+module.exports = __toCommonJS(AccountList_exports);
+var import_Account = require("../Account");
+var import_BaseModule = require("../BaseModule");
+var import_types = require("./types");
+var AccountListModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "accountList";
+    this.defaultVersion = "1.0.0";
+    this.store = {
+      accounts: [],
+      isLoading: false,
+      error: null
+    };
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.store = options == null ? void 0 : options.store;
+    this.store.accounts = [];
+  }
+  async addAccount(account) {
+    try {
+      this.store.isLoading = true;
+      this.store.error = null;
+      if (this.store.accounts.some((a) => a.getId() === account.id)) {
+        throw new Error(`Account with id ${account.id} already exists`);
+      }
+      const accountModule = new import_Account.AccountModule(`account_${account.id}`);
+      this.core.registerModule(accountModule);
+      this.store.accounts = [...this.store.accounts, accountModule];
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListUpdate, this.store);
+    } catch (error) {
+      this.store.error = error instanceof Error ? error.message : "Failed to add account";
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListError, this.store.error);
+    } finally {
+      this.store.isLoading = false;
+    }
+  }
+  async updateAccount(id, updates) {
+    try {
+      this.store.isLoading = true;
+      this.store.error = null;
+      const account = this.getAccount(id);
+      if (!account) {
+        throw new Error(`Account with id ${id} not found`);
+      }
+      Object.assign(account, updates);
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListUpdate, this.store);
+    } catch (error) {
+      this.store.error = error instanceof Error ? error.message : "Failed to update account";
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListError, this.store.error);
+    } finally {
+      this.store.isLoading = false;
+    }
+  }
+  async removeAccount(id) {
+    try {
+      this.store.isLoading = true;
+      this.store.error = null;
+      const index = this.store.accounts.findIndex((a) => a.getId() === id);
+      if (index === -1) {
+        throw new Error(`Account with id ${id} not found`);
+      }
+      this.store.accounts[index].destory();
+      this.store.accounts = [
+        ...this.store.accounts.slice(0, index),
+        ...this.store.accounts.slice(index + 1)
+      ];
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListUpdate, this.store);
+    } catch (error) {
+      this.store.error = error instanceof Error ? error.message : "Failed to remove account";
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListError, this.store.error);
+    } finally {
+      this.store.isLoading = false;
+    }
+  }
+  getAccounts() {
+    return [...this.store.accounts];
+  }
+  getAccount(id) {
+    return this.store.accounts.find((account) => account.getId() === id) || null;
+  }
+  async clearAccounts() {
+    try {
+      this.store.isLoading = true;
+      this.store.error = null;
+      this.store.accounts = [];
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListUpdate, this.store);
+    } catch (error) {
+      this.store.error = error instanceof Error ? error.message : "Failed to clear accounts";
+      await this.core.effects.emit(import_types.AccountListHooks.OnAccountListError, this.store.error);
+    } finally {
+      this.store.isLoading = false;
+    }
+  }
+  getState() {
+    return { ...this.store };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountListModule
+});

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

@@ -0,0 +1,37 @@
+import { Account, AccountModule } from "../Account";
+export declare enum AccountListHooks {
+    OnAccountListUpdate = "accountList:onUpdate",
+    OnAccountListError = "accountList:onError"
+}
+/**
+ * 账户列表查询参数
+ */
+export interface AccountListQuery {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    filters?: Record<string, any>;
+}
+/**
+ * 账户列表状态
+ */
+export interface AccountListState {
+    accounts: AccountModule[];
+    isLoading: boolean;
+    error: string | null;
+}
+/**
+ * 账户列表模块 API
+ */
+export interface AccountListModuleAPI {
+    addAccount: (account: Account) => Promise<void>;
+    updateAccount: (id: string, updates: Partial<AccountModule>) => Promise<void>;
+    removeAccount: (id: string) => Promise<void>;
+    getAccounts: () => AccountModule[];
+    getAccount: (id: string) => AccountModule | null;
+    clearAccounts: () => Promise<void>;
+    addAccounts: (accounts: AccountModule[]) => Promise<void>;
+    getState: () => AccountListState;
+}

package/lib/modules/AccountList/types.js

@@ -0,0 +1,33 @@
+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/AccountList/types.ts
+var types_exports = {};
+__export(types_exports, {
+  AccountListHooks: () => AccountListHooks
+});
+module.exports = __toCommonJS(types_exports);
+var AccountListHooks = /* @__PURE__ */ ((AccountListHooks2) => {
+  AccountListHooks2["OnAccountListUpdate"] = "accountList:onUpdate";
+  AccountListHooks2["OnAccountListError"] = "accountList:onError";
+  return AccountListHooks2;
+})(AccountListHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountListHooks
+});

package/lib/modules/BaseModule.js

@@ -32,6 +32,7 @@ var BaseModule = class {
   }
   destory() {
     this.core.effects.offByModuleDestroy(this.name);
+    this.core.unregisterModule(this);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -28,6 +28,8 @@ export declare class CartModule extends BaseModule implements Module {
     getItemCount(): number;
     getTotalPrice(): number;
     getItems(): Promise<CartItem[]>;
-    updateItemQuantity(id: string, quantity: number): Promise<void>;
+    updateItem(id: string, item: CartItem): Promise<void>;
     removeItem(id: string): Promise<void>;
+    storeTemp(key: string, value: any): Promise<void>;
+    getTemp(key?: string): Promise<any>;
 }

package/lib/modules/Cart/index.js

@@ -38,7 +38,7 @@ var CartModule = class extends import_BaseModule.BaseModule {
       getItemCount: this.getItemCount.bind(this),
       getTotalPrice: this.getTotalPrice.bind(this),
       getItems: this.getItems.bind(this),
-      updateItemQuantity: this.updateItemQuantity.bind(this),
+      updateItem: this.updateItem.bind(this),
       removeItem: this.removeItem.bind(this)
     };
   }
@@ -56,6 +56,7 @@ var CartModule = class extends import_BaseModule.BaseModule {
     if (!this.window) {
       throw new Error("购物车模块需要 window 插件支持");
     }
+    this.store.temp = {};
     console.log("[CartModule] 初始化完成");
   }
   /**
@@ -82,11 +83,11 @@ var CartModule = class extends import_BaseModule.BaseModule {
   async getItems() {
     return this.store.list;
   }
-  async updateItemQuantity(id, quantity) {
+  async updateItem(id, item) {
     const items = this.store.list;
     const itemIndex = items.findIndex((i) => i.id === id);
     if (itemIndex !== -1) {
-      items[itemIndex] = { ...items[itemIndex], quantity };
+      items[itemIndex] = item;
       this.store.list = items;
       await this.core.effects.emit(import_types.CartHooks.OnCartUpdateItem, items);
     }
@@ -96,6 +97,15 @@ var CartModule = class extends import_BaseModule.BaseModule {
     this.store.list = items;
     await this.core.effects.emit(import_types.CartHooks.OnCartRemove, items);
   }
+  async storeTemp(key, value) {
+    this.store.temp[key] = value;
+  }
+  async getTemp(key) {
+    if (!key) {
+      return this.store.temp;
+    }
+    return this.store.temp[key];
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -10,7 +10,6 @@ export declare enum CartHooks {
  */
 export interface CartItem {
     id: string;
-    name: string;
     price: number;
     quantity: number;
     product: ProductData;
@@ -19,8 +18,9 @@ export interface CartItem {
  * 购物车状态接口
  */
 export interface CartState {
-    list: CartItem[];
+    list: any[];
     total: number;
+    temp: Record<string, any>;
 }
 /**
  * 购物车模块 API
@@ -30,6 +30,6 @@ export interface CartModuleAPI {
     getItemCount: () => number;
     getTotalPrice: () => number;
     getItems: () => Promise<CartItem[]>;
-    updateItemQuantity: (id: string, quantity: number) => Promise<void>;
+    updateItem: (id: string, item: CartItem) => Promise<void>;
     removeItem: (id: string) => Promise<void>;
 }

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

@@ -1,6 +1,7 @@
 export declare enum DateHooks {
     OnDateChange = "date:onDateChange",
-    OnTimeSlotChange = "date:onTimeSlotChange"
+    OnTimeSlotChange = "date:onTimeSlotChange",
+    OnGetDateList = "date:onGetDateList"
 }
 /**
  * 时间槽位

package/lib/modules/Date/types.js

@@ -25,6 +25,7 @@ module.exports = __toCommonJS(types_exports);
 var DateHooks = /* @__PURE__ */ ((DateHooks2) => {
   DateHooks2["OnDateChange"] = "date:onDateChange";
   DateHooks2["OnTimeSlotChange"] = "date:onTimeSlotChange";
+  DateHooks2["OnGetDateList"] = "date:onGetDateList";
   return DateHooks2;
 })(DateHooks || {});
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -12,5 +12,5 @@ export declare class ProductList extends BaseModule implements Module {
     storeChange(path?: string, value?: any): Promise<void>;
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<Product | undefined>;
-    addProduct(): Promise<void>;
+    addProduct(products: ProductData[]): Promise<void>;
 }

package/lib/modules/ProductList/index.js

@@ -35,16 +35,16 @@ var ProductList = class extends import_BaseModule.BaseModule {
   }
   async initialize(core, options) {
     this.core = core;
-    this.store = {
-      ...options.store || {},
-      productMap: /* @__PURE__ */ new Map()
-    };
+    this.store = options.store;
+    this.store.productMap = /* @__PURE__ */ new Map();
+    this.store.list = [];
     this.storeChange();
   }
   async storeChange(path, value) {
-    this.store.list.forEach((product) => {
+    var _a;
+    (_a = this.store.list) == null ? void 0 : _a.forEach((product) => {
       if (!this.store.productMap.has(`product-${product.id}`)) {
-        const newProductModule = new import_Product.Product(`product-${product.id.toString()}`);
+        const newProductModule = new import_Product.Product(`product_${product.id.toString()}`);
         this.core.registerModule(newProductModule, { initialState: product });
         this.store.productMap.set(product.id.toString(), newProductModule);
       }
@@ -61,7 +61,8 @@ var ProductList = class extends import_BaseModule.BaseModule {
       return product;
     return void 0;
   }
-  async addProduct() {
+  async addProduct(products) {
+    this.store.list = [...this.store.list, ...products];
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,10 +1,12 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { Resource, ResourceTimeSlot, ResourceListModuleAPI } from './types';
-export declare class ResourceListModule extends BaseModule implements Module, ResourceListModuleAPI {
-    private state;
-    constructor();
-    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+import { Resource, ResourceTimeSlot } from './types';
+export declare class ResourceListModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    constructor(name: string, version: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     getResources(): Promise<Resource[]>;
     selectResource(resourceId: string): Promise<void>;
     getSelectedResource(): Resource | null;

package/lib/modules/Resource/index.js

@@ -25,34 +25,30 @@ module.exports = __toCommonJS(Resource_exports);
 var import_BaseModule = require("../BaseModule");
 var import_types = require("./types");
 var ResourceListModule = class extends import_BaseModule.BaseModule {
-  constructor() {
-    super("resource", "1.0.0");
-    this.state = {
-      list: [],
-      selectedResource: null
-    };
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "resourceList";
+    this.defaultVersion = "1.0.0";
   }
   async initialize(core, options) {
     this.core = core;
-    if (options == null ? void 0 : options.initialState) {
-      this.state = { ...this.state, ...options.initialState };
-    }
+    this.store = options.store;
   }
   async getResources() {
-    return this.state.list;
+    return this.store.list;
   }
   async selectResource(resourceId) {
-    const resource = this.state.list.find((r) => r.id === resourceId);
+    const resource = this.store.list.find((r) => r.id === resourceId);
     if (!resource)
       return;
-    this.state.selectedResource = resource;
+    this.store.selectedResource = resource;
     await this.core.effects.emit(import_types.ResourceHooks.OnResourceSelect, resource);
   }
   getSelectedResource() {
-    return this.state.selectedResource;
+    return this.store.selectedResource;
   }
   async checkAvailability(resourceId, start, end) {
-    const resource = this.state.list.find((r) => r.id === resourceId);
+    const resource = this.store.list.find((r) => r.id === resourceId);
     if (!resource)
       return false;
     return resource.timeSlots.some(
@@ -60,13 +56,13 @@ var ResourceListModule = class extends import_BaseModule.BaseModule {
     );
   }
   async getAvailableTimeSlots(resourceId) {
-    const resource = this.state.list.find((r) => r.id === resourceId);
+    const resource = this.store.list.find((r) => r.id === resourceId);
     if (!resource)
       return [];
     return resource.timeSlots.filter((slot) => slot.availableCapacity > 0);
   }
   getAvailableCapacity(resourceId, timeSlot) {
-    const resource = this.state.list.find((r) => r.id === resourceId);
+    const resource = this.store.list.find((r) => r.id === resourceId);
     if (!resource)
       return 0;
     const slot = resource.timeSlots.find(
@@ -75,14 +71,14 @@ var ResourceListModule = class extends import_BaseModule.BaseModule {
     return (slot == null ? void 0 : slot.availableCapacity) || 0;
   }
   async updateResource(resourceId, updates) {
-    const index = this.state.list.findIndex((r) => r.id === resourceId);
+    const index = this.store.list.findIndex((r) => r.id === resourceId);
     if (index === -1)
       return;
-    this.state.list[index] = {
-      ...this.state.list[index],
+    this.store.list[index] = {
+      ...this.store.list[index],
       ...updates
     };
-    await this.core.effects.emit(import_types.ResourceHooks.OnResourceChange, this.state.list[index]);
+    await this.core.effects.emit(import_types.ResourceHooks.OnResourceChange, this.store.list[index]);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/modules/Resource/utils.d.ts

@@ -0,0 +1,23 @@
+interface Resource {
+    id: string;
+    [key: string]: any;
+}
+/**
+ * @title: 获取资源map
+ * @description:
+ * @param {any} resourceList
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const getResourcesMap: (resourceList: Resource[]) => Record<string, Resource>;
+/**
+ * @title: 根据ids筛选资源列表
+ * @description:
+ * @param {any} resourcesMap
+ * @param {any} ids
+ * @return {*}
+ * @Author: zhiwei.Wang
+ * @Date: 2024-09-19 20:23
+ */
+export declare const getResourcesByIds: (resourcesMap: Record<string, Resource>, ids: number[]) => Resource[];
+export {};

package/lib/modules/Resource/utils.js

@@ -0,0 +1,39 @@
+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/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getResourcesByIds: () => getResourcesByIds,
+  getResourcesMap: () => getResourcesMap
+});
+module.exports = __toCommonJS(utils_exports);
+var getResourcesMap = (resourceList) => {
+  return resourceList.reduce((pre, item) => {
+    pre[item.id] = item;
+    return pre;
+  }, {});
+};
+var getResourcesByIds = (resourcesMap, ids) => {
+  return (ids || []).map((id) => resourcesMap[id]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getResourcesByIds,
+  getResourcesMap
+});

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

@@ -0,0 +1,19 @@
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { IStep, IStepModuleAPI } from "./tyeps";
+export declare class StepModule extends BaseModule implements Module, IStepModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    init(steps: IStep[]): void;
+    private setSteps;
+    private setCurrentStep;
+    getStepList(): IStep[];
+    getCurrentStep(): IStep;
+    getCurrentStepIndex(): number;
+    prevStep(): void;
+    nextStep(): void;
+    gotoStep(stepIndex: number): void;
+}

package/lib/modules/Step/index.js

@@ -0,0 +1,76 @@
+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/Step/index.ts
+var Step_exports = {};
+__export(Step_exports, {
+  StepModule: () => StepModule
+});
+module.exports = __toCommonJS(Step_exports);
+var import_BaseModule = require("../BaseModule");
+var StepModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "step";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.store = options.store;
+  }
+  init(steps) {
+    this.setSteps(steps);
+    this.setCurrentStep(0);
+  }
+  setSteps(stepList) {
+    this.store.stepList = stepList;
+  }
+  setCurrentStep(stepIndex) {
+    if (stepIndex < 0 || stepIndex >= this.store.stepList.length) {
+      return;
+    }
+    this.store.currentStepIndex = stepIndex;
+    this.store.currentStep = this.store.stepList[stepIndex];
+  }
+  getStepList() {
+    return this.store.stepList;
+  }
+  getCurrentStep() {
+    return this.store.currentStep;
+  }
+  getCurrentStepIndex() {
+    return this.store.currentStepIndex;
+  }
+  prevStep() {
+    if (this.store.currentStepIndex > 0) {
+      this.setCurrentStep(this.store.currentStepIndex - 1);
+    }
+  }
+  nextStep() {
+    if (this.store.currentStepIndex < this.store.stepList.length - 1) {
+      this.setCurrentStep(this.store.currentStepIndex + 1);
+    }
+  }
+  gotoStep(stepIndex) {
+    this.setCurrentStep(stepIndex);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StepModule
+});

package/lib/modules/Step/tyeps.d.ts

@@ -0,0 +1,18 @@
+export interface IStepState {
+    stepList: IStep[];
+    currentStep: IStep;
+    currentStepIndex: number;
+}
+export interface IStep {
+    index: number;
+    key: string;
+    [key: string]: any;
+}
+export interface IStepModuleAPI {
+    getStepList: () => IStep[];
+    getCurrentStep: () => IStep;
+    getCurrentStepIndex: () => number;
+    nextStep: () => void;
+    prevStep: () => void;
+    gotoStep: (stepIndex: number) => void;
+}

package/lib/modules/Step/tyeps.js

@@ -0,0 +1,17 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Step/tyeps.ts
+var tyeps_exports = {};
+module.exports = __toCommonJS(tyeps_exports);