@mu-cabin/opms-permission 0.8.35 → 0.9.2

package/dist/index.cjs

@@ -31,17 +31,48 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   DataHandler: () => DataHandler,
+  EnumOrgQueryMode: () => EnumOrgQueryMode,
+  EnumOrgQueryScope: () => EnumOrgQueryScope,
+  EventEmitter: () => EventEmitter,
   OpmsPermission: () => Permission,
+  getOrgTree: () => getOrgTree,
+  getUserInfo: () => getUserInfo,
+  getUserOrgTree: () => getUserOrgTree,
   jumpToSSOLogin: () => jumpToSSOLogin,
-  jumpToSSOLogout: () => jumpToSSOLogout
+  jumpToSSOLogout: () => jumpToSSOLogout,
+  login: () => login,
+  logout: () => logout,
+  queryOrgCompanies: () => queryOrgCompanies,
+  queryResource: () => queryResource
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/utils/storage.ts
 var Storage = class {
+  constructor() {
+    this.currentVersion = "1.0.0";
+  }
   setSystemId(systemId) {
     this.systemId = systemId;
   }
+  /**
+   * Set the current version for new data
+   * If version changes, all existing data for this systemId will be cleared
+   */
+  setVersion(version) {
+    if (this.currentVersion !== version) {
+      this.clear();
+      this.currentVersion = version;
+    } else {
+      this.currentVersion = version;
+    }
+  }
+  /**
+   * Get the current version
+   */
+  getVersion() {
+    return this.currentVersion;
+  }
   prefixKey(key) {
     return this.systemId !== void 0 ? `systemId-${this.systemId}-${key}` : key;
   }
@@ -51,24 +82,35 @@ var Storage = class {
   setItem(key, value, expireMinutes) {
     const data = {
       value,
-      expire: expireMinutes ? Date.now() + expireMinutes * 60 * 1e3 : null
+      expire: expireMinutes ? Date.now() + expireMinutes * 60 * 1e3 : null,
+      version: this.currentVersion,
+      timestamp: Date.now()
     };
     localStorage.setItem(this.prefixKey(key), JSON.stringify(data));
   }
   /**
    * Get an item from localStorage, returns undefined if expired or not found
+   * Automatically expires data if version is different
    */
   getItem(key) {
     const raw = localStorage.getItem(this.prefixKey(key));
     if (!raw) return void 0;
     try {
       const data = JSON.parse(raw);
+      if (!data.version) {
+        data.version = "0.0.0";
+      }
       if (data.expire && Date.now() > data.expire) {
         localStorage.removeItem(this.prefixKey(key));
         return void 0;
       }
+      if (data.version !== this.currentVersion) {
+        localStorage.removeItem(this.prefixKey(key));
+        return void 0;
+      }
       return data.value;
-    } catch {
+    } catch (error) {
+      console.error("Error parsing stored data:", error);
       return void 0;
     }
   }
@@ -78,6 +120,44 @@ var Storage = class {
   removeItem(key) {
     localStorage.removeItem(this.prefixKey(key));
   }
+  /**
+   * Clear all data for the current systemId
+   */
+  clear() {
+    if (this.systemId !== void 0) {
+      const prefix = `systemId-${this.systemId}-`;
+      Object.keys(localStorage).filter((key) => key.startsWith(prefix)).forEach((key) => localStorage.removeItem(key));
+    }
+  }
+  /**
+   * Get all keys for the current systemId
+   */
+  getKeys() {
+    if (this.systemId === void 0) {
+      return Object.keys(localStorage);
+    }
+    const prefix = `systemId-${this.systemId}-`;
+    return Object.keys(localStorage).filter((key) => key.startsWith(prefix)).map((key) => key.substring(prefix.length));
+  }
+  /**
+   * Check if a key exists
+   */
+  hasKey(key) {
+    return localStorage.getItem(this.prefixKey(key)) !== null;
+  }
+  /**
+   * Get storage info for debugging
+   */
+  getStorageInfo() {
+    const totalKeys = Object.keys(localStorage).length;
+    const systemKeys = this.getKeys().length;
+    return {
+      systemId: this.systemId,
+      currentVersion: this.currentVersion,
+      totalKeys,
+      systemKeys
+    };
+  }
 };
 var storage = new Storage();
 
@@ -233,8 +313,6 @@ var import_axios = __toESM(require("axios"));
 var USER_INFO_KEY = "opms_user_info";
 var RESOURCE_KEY = "opms_resources";
 var TOKEN_KEY = "omps_authorization";
-var ORG_COMPANY_KEY = "opms_org_company";
-var USER_ORG_KEY = "opms_user_org";
 
 // src/api.ts
 var axiosClient = import_axios.default.create();
@@ -261,6 +339,17 @@ axiosClient.interceptors.response.use(
     return Promise.reject(error);
   }
 );
+var EnumOrgQueryMode = /* @__PURE__ */ ((EnumOrgQueryMode2) => {
+  EnumOrgQueryMode2["BY_ROLES"] = "BY_ROLES";
+  EnumOrgQueryMode2["BY_DEPT"] = "BY_DEPT";
+  return EnumOrgQueryMode2;
+})(EnumOrgQueryMode || {});
+var EnumOrgQueryScope = /* @__PURE__ */ ((EnumOrgQueryScope2) => {
+  EnumOrgQueryScope2["ONLY_BRANCH"] = "ONLY_BRANCH";
+  EnumOrgQueryScope2["STEWARD_UNIT"] = "STEWARD_UNIT";
+  EnumOrgQueryScope2["WITH_DEPARTMENT"] = "WITH_DEPARTMENT";
+  return EnumOrgQueryScope2;
+})(EnumOrgQueryScope || {});
 async function login(baseUrl, authorizationCode) {
   return await axiosClient.get(
     `${baseUrl}/opmsDefaultAuth/oauthLogin`,
@@ -286,9 +375,16 @@ async function queryResource(baseUrl, params) {
     params
   );
 }
-async function getUserOrgTree(baseUrl) {
+async function getOrgTree(baseUrl, params) {
   return await axiosClient.post(
-    `${baseUrl}/user/orgTree`
+    `${baseUrl}/opmsDefaultUser/orgTree`,
+    params
+  );
+}
+async function getUserOrgTree(baseUrl, params) {
+  return await axiosClient.post(
+    `${baseUrl}/opmsDefaultUser/userOrgTree`,
+    params
   );
 }
 async function queryOrgCompanies(baseUrl, params) {
@@ -298,6 +394,104 @@ async function queryOrgCompanies(baseUrl, params) {
   );
 }
 
+// src/utils/eventEmitter.ts
+var EventEmitter = class {
+  constructor(allowedEvents) {
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.allowedEvents = new Set(allowedEvents || []);
+  }
+  /**
+   * Add event listener
+   */
+  listen(event, listener) {
+    if (this.allowedEvents.size > 0 && !this.allowedEvents.has(event)) {
+      const allowedEventsList = Array.from(this.allowedEvents).join(", ");
+      throw new Error(
+        `Event "${String(event)}" is not registered. Allowed events: ${allowedEventsList}`
+      );
+    }
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.eventListeners.get(event);
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.eventListeners.delete(event);
+      }
+    };
+  }
+  /**
+   * Remove event listener
+   */
+  unlisten(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.eventListeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Remove all listeners for a specific event or all events
+   */
+  unlistenAll(event) {
+    if (event) {
+      this.eventListeners.delete(event);
+    } else {
+      this.eventListeners.clear();
+    }
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((listener) => {
+        try {
+          listener(data);
+        } catch (error) {
+          console.error(`Error in event listener for ${String(event)}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Get the number of listeners for a specific event
+   */
+  getListenerCount(event) {
+    const listeners = this.eventListeners.get(event);
+    return listeners ? listeners.size : 0;
+  }
+  /**
+   * Check if there are any listeners for a specific event
+   */
+  hasListeners(event) {
+    return this.getListenerCount(event) > 0;
+  }
+  /**
+   * Get all registered event types
+   */
+  getEventTypes() {
+    return Array.from(this.eventListeners.keys());
+  }
+  /**
+   * Get all allowed event types
+   */
+  getAllowedEvents() {
+    return Array.from(this.allowedEvents);
+  }
+  /**
+   * Check if an event is allowed
+   */
+  isEventAllowed(event) {
+    return this.allowedEvents.size === 0 || this.allowedEvents.has(event);
+  }
+};
+
 // src/permission.ts
 var DataHandler = {
   iterateOrgTree(orgTree) {
@@ -363,16 +557,63 @@ var DataHandler = {
 var Permission = class {
   constructor(options) {
     this._userInfo = null;
-    this._orgTree = null;
-    this._orgCompany = null;
     this.resources = [];
     this.resourceMap = {};
     this.widgetMap = {};
     this.menuList = [];
     this.menuMap = {};
+    // Event emitter instance - only allow tokenChange event
+    this.eventEmitter = new EventEmitter(["tokenChange"]);
     this.baseUrl = options.baseUrl;
     this.systemId = options.systemId;
     storage.setSystemId(this.systemId);
+    storage.setVersion("1.0.0");
+  }
+  /**
+   * Add event listener
+   */
+  listen(event, listener) {
+    try {
+      return this.eventEmitter.listen(event, listener);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not registered")) {
+        const allowedEvents = this.eventEmitter.getAllowedEvents();
+        throw new Error(
+          `Permission event "${String(event)}" is not supported. Available events: ${allowedEvents.join(", ")}`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Remove event listener
+   */
+  unlisten(event, listener) {
+    this.eventEmitter.unlisten(event, listener);
+  }
+  /**
+   * Remove all listeners for a specific event or all events
+   */
+  unlistenAll(event) {
+    this.eventEmitter.unlistenAll(event);
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emit(event, data) {
+    this.eventEmitter.emit(event, data);
+  }
+  /**
+   * Get available events that can be listened to
+   */
+  getAvailableEvents() {
+    return this.eventEmitter.getAllowedEvents();
+  }
+  /**
+   * Check if an event is supported
+   */
+  isEventSupported(event) {
+    return this.eventEmitter.isEventAllowed(event);
   }
   /**
    * Login using code from URL, save userInfo
@@ -400,6 +641,7 @@ var Permission = class {
     const { token } = obj;
     url.searchParams.delete("code");
     storage.setItem(TOKEN_KEY, token);
+    this.emit("tokenChange", token);
     return token;
   }
   /**
@@ -410,25 +652,13 @@ var Permission = class {
     clearData && this.clear();
   }
   clear() {
-    this._userInfo = null;
-    this._orgTree = null;
-    this._orgCompany = null;
-    this.resources = [];
-    this.resourceMap = {};
-    this.widgetMap = {};
-    this.menuList = [];
-    this.menuMap = {};
-    storage.removeItem(RESOURCE_KEY);
-    storage.removeItem(TOKEN_KEY);
-    storage.removeItem(USER_INFO_KEY);
-    storage.removeItem(ORG_COMPANY_KEY);
-    storage.removeItem(USER_ORG_KEY);
+    storage.clear();
+    this.emit("tokenChange", "");
   }
   async getUserInfo() {
     const data = await getUserInfo(this.baseUrl);
     const { obj, success, msg, code } = data;
-    this._userInfo = obj;
-    return this.userInfo;
+    return obj;
   }
   /**
    * Get resources and process to menuList, menuMap, widgetMap (matches app store logic)
@@ -449,17 +679,12 @@ var Permission = class {
       storage.setItem(
         RESOURCE_KEY,
         resources,
-        60 * 24
-        // 24 hours
+        60 * 12
+        // 12 hours
       );
     }
     const { resourceMap, widgetMap } = createResourceMap(resources);
     const { menuList, menuMap } = createMenuList(resources);
-    this.resources = resources;
-    this.resourceMap = resourceMap;
-    this.widgetMap = widgetMap;
-    this.menuList = menuList;
-    this.menuMap = menuMap;
     return {
       resources,
       resourceMap,
@@ -469,13 +694,28 @@ var Permission = class {
     };
   }
   /**
-   * Query and process organization tree
+   * Generate cache key for user orgs query
    */
-  async queryUserOrgs() {
+  generateUserOrgsCacheKey(params) {
+    const sortedParams = Object.keys(params).sort().reduce((acc, key) => {
+      acc[key] = params[key];
+      return acc;
+    }, {});
+    return `user_orgs_${JSON.stringify(sortedParams)}`;
+  }
+  /**
+   * Query and process organization tree with caching
+   */
+  async queryUserOrgs(params, config = { force: false, cacheTimeout: 2 }) {
     try {
-      let orgTreeData = storage.getItem(USER_ORG_KEY) || null;
+      const { force, cacheTimeout = 2 } = config;
+      let orgTreeData = null;
+      if (!force) {
+        const cacheKey = this.generateUserOrgsCacheKey(params);
+        orgTreeData = storage.getItem(cacheKey) || null;
+      }
       if (!orgTreeData) {
-        const res = await getUserOrgTree(this.baseUrl);
+        const res = await getUserOrgTree(this.baseUrl, params);
         const { obj } = res;
         orgTreeData = iterateNestedArray(obj, (item) => {
           return {
@@ -490,33 +730,33 @@ var Permission = class {
             orgId: item.orgId
           };
         });
-        storage.setItem(USER_ORG_KEY, orgTreeData);
+        const cacheKey = this.generateUserOrgsCacheKey(params);
+        storage.setItem(cacheKey, orgTreeData, cacheTimeout);
       }
       const data = handlePermissionTree(orgTreeData, "orgId");
-      const { noAuthMap } = data;
-      let { tree } = data;
-      if (tree.length === 1 && tree[0].orgType === "HEAD" && tree[0].disabled) {
-        tree = tree[0].children || [];
-      }
-      this._orgTree = orgTreeData;
-      return { orgTree: orgTreeData, orgNoAuthMap: noAuthMap, authOrgTree: tree };
+      const { tree } = data;
+      return {
+        orgTree: tree
+        // orgNoAuthMap: noAuthMap,
+        // authOrgTree: tree,
+      };
     } catch (error) {
       console.log(error);
       return null;
     }
   }
-  async queryCompanies() {
-    let orgCompanyList = storage.getItem(ORG_COMPANY_KEY);
-    if (!orgCompanyList) {
-      const { obj } = await queryOrgCompanies(this.baseUrl, {
-        queryAllBranches: true
-      });
-      orgCompanyList = obj;
-      storage.setItem(ORG_COMPANY_KEY, orgCompanyList);
-    }
-    this._orgCompany = orgCompanyList;
-    return orgCompanyList;
-  }
+  // async queryCompanies(): Promise<OrgRecord[]> {
+  //   let orgCompanyList: OrgRecord[] | undefined =
+  //     storage.getItem(ORG_COMPANY_KEY);
+  //   if (!orgCompanyList) {
+  //     const { obj } = await queryOrgCompanies(this.baseUrl, {
+  //       queryAllBranches: true,
+  //     });
+  //     orgCompanyList = obj;
+  //     storage.setItem(ORG_COMPANY_KEY, orgCompanyList);
+  //   }
+  //   return orgCompanyList;
+  // }
   isLogin() {
     return !!storage.getItem(TOKEN_KEY);
   }
@@ -525,72 +765,77 @@ var Permission = class {
   }
   setToken(token) {
     storage.setItem(TOKEN_KEY, token);
+    this.emit("tokenChange", token);
   }
   // --- Getters ---
-  get userInfo() {
-    if (!this._userInfo) {
-      this._userInfo = storage.getItem(USER_INFO_KEY);
-    }
-    if (!this._userInfo) return null;
-    const { account, name, ehrId, crewCode, crewId } = this._userInfo;
-    return { account, name, ehrId, crewCode, crewId };
-  }
-  get hasRootAuth() {
-    const orgs = this._userInfo?.organizations || [];
-    const first = orgs[0];
-    if (!first) return false;
-    return first.searchPath === "#1";
-  }
-  get userOrganizations() {
-    return this._userInfo?.userOrganizations || [];
-  }
-  get allCompanyOptions() {
-    const orgCompany = this._orgCompany;
-    if (!orgCompany) return [];
-    const list = orgCompany.map((v) => ({
-      label: v.orgName,
-      value: v.orgCode
-    }));
-    list.unshift({ label: "\u5168\u516C\u53F8", value: "EA" });
-    return list;
-  }
-  get companyOptions() {
-    const orgTree = this._orgTree;
-    if (!orgTree) return [];
-    const list = orgTree.map(({ children, ...others }) => ({
-      ...others,
-      disabled: false
-    }));
-    if (this.hasRootAuth) {
-      list.unshift({ ...orgTree, label: "\u5168\u516C\u53F8", children: [] });
-    }
-    return list;
-  }
-  get firstCompanyOrgCode() {
-    return this.companyOptions?.[0]?.value ?? "";
+  // get userInfo(): UserInfo | null {
+  //   if (!this._userInfo) {
+  //     this._userInfo = storage.getItem(USER_INFO_KEY);
+  //   }
+  //   if (!this._userInfo) return null;
+  //   const { account, name, ehrId, crewCode, crewId } = this._userInfo;
+  //   return { account, name, ehrId, crewCode, crewId };
+  // }
+  // get hasRootAuth() {
+  //   const orgs = this._userInfo?.organizations || [];
+  //   const first = orgs[0];
+  //   if (!first) return false;
+  //   return first.searchPath === '#1';
+  // }
+  // get userOrganizations(): UserOrganization[] {
+  //   return this._userInfo?.userOrganizations || [];
+  // }
+  /**
+   * Get storage information for debugging and monitoring
+   */
+  getStorageInfo() {
+    const keys = storage.getKeys();
+    const userOrgsCacheKeys = keys.filter((key) => key.startsWith("user_orgs_"));
+    return {
+      ...storage.getStorageInfo(),
+      permissionKeys: {
+        resourceKey: RESOURCE_KEY,
+        tokenKey: TOKEN_KEY,
+        userInfoKey: USER_INFO_KEY
+      },
+      hasData: {
+        resources: storage.hasKey(RESOURCE_KEY),
+        token: storage.hasKey(TOKEN_KEY),
+        userInfo: storage.hasKey(USER_INFO_KEY)
+      },
+      cacheInfo: {
+        userOrgsCacheCount: userOrgsCacheKeys.length,
+        userOrgsCacheKeys
+      }
+    };
   }
-  get unitOptions() {
-    const orgTree = this._orgTree;
-    if (!orgTree) return [];
-    return orgTree;
+  /**
+   * Get current storage version
+   */
+  getStorageVersion() {
+    return storage.getVersion();
   }
-  get allUnitOptions() {
-    const orgTree = this._orgTree;
-    if (!orgTree) return [];
-    return DataHandler.getAllUnitOptions(orgTree);
+  /**
+   * Clear all storage data for this system
+   */
+  clearStorage() {
+    storage.clear();
   }
-  get firstUnitOrgCode() {
-    if (this.hasRootAuth) {
-      return this.companyOptions[1]?.value ?? "";
+  /**
+   * Clear user orgs cache for specific parameters or all
+   */
+  clearUserOrgsCache(params) {
+    if (params) {
+      const cacheKey = this.generateUserOrgsCacheKey(params);
+      storage.removeItem(cacheKey);
+    } else {
+      const keys = storage.getKeys();
+      keys.forEach((key) => {
+        if (key.startsWith("user_orgs_")) {
+          storage.removeItem(key);
+        }
+      });
     }
-    const orgTree = this._orgTree;
-    if (!orgTree) return "";
-    return findFirstEnableCode(orgTree) ?? "";
-  }
-  get topLevelUnitOrgCodes() {
-    const orgTree = this._orgTree;
-    if (!orgTree) return [];
-    return DataHandler.topLevelUnitOrgCodes(orgTree);
   }
 };
 
@@ -631,7 +876,17 @@ function jumpToSSOLogout({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataHandler,
+  EnumOrgQueryMode,
+  EnumOrgQueryScope,
+  EventEmitter,
   OpmsPermission,
+  getOrgTree,
+  getUserInfo,
+  getUserOrgTree,
   jumpToSSOLogin,
-  jumpToSSOLogout
+  jumpToSSOLogout,
+  login,
+  logout,
+  queryOrgCompanies,
+  queryResource
 });