@microbt/environment 0.2.0 → 0.3.1

package/README.md

@@ -60,17 +60,28 @@ console.log(regionCode); // 输出: 'cn'
 
 ## 网关相关函数
 
-### `baseUrl()`
+### `baseUrl(params: { name: string; path?: string })`
 
-获取 API 的基础 URL。
+根据当前域名生成对应的 API URL。
 
-**返回值**: `string | undefined` - 根据环境返回相应的 API 基础 URL，如果是本地或未知环境则返回 `undefined`
+**参数**:
+
+- `params.name`: `string` - **必填**，API 服务名称（如 'api'、'iot-api'）
+- `params.path`: `string` - **可选**，API 路径（如 '/saas'）
+
+**返回值**: `string` - 生成的 URL。如果生成失败则返回传入的 path 值
 
 **示例**:
 
 ```typescript
-const url = baseUrl();
-console.log(url); // 输出: '//api-cn-prod.superacme.com'
+// 中国区开发环境
+// location.host: 'mall-cn-dev.superacme.com'
+baseUrl({ name: 'api' }); // => '//api-cn-dev.superacme.com'
+baseUrl({ name: 'iot-api', path: '/saas' }); // => '//iot-api-cn-dev.superacme.com/saas'
+
+// 美区 AWS 生产环境
+// location.host: 'mall-us-aws.superacme.com'
+baseUrl({ name: 'api' }); // => '//api-us-aws.superacme.com'
 ```
 
 ## 混合应用相关函数
@@ -117,15 +128,36 @@ console.log(isInApp); // 输出: true 或 false
 
 ### `superAcmeVersion()`
 
-获取 SuperAcme 应用的版本号。
+获取 SuperAcme 应用的版本信息。
+
+**返回值**: 返回一个包含版本信息的对象：
+
+- 如果在 SuperAcme 应用中且能够解析版本号：
 
-**返回值**: `string | undefined` - 返回 SuperAcme 应用的版本号，如果不在应用中则返回 `undefined`
+  ```json
+  {
+    version: string; // 完整版本号，如 "1.2.3"
+    major: number; // 主版本号
+    minor: number; // 次版本号
+    patch: number; // 修订号
+  }
+  ```
+
+- 如果不在 SuperAcme 应用中或无法解析版本号：
+
+  ```json
+  {
+    version: 'unknown';
+  }
+  ```
 
 **示例**:
 
 ```typescript
-const version = superAcmeVersion();
-console.log(version); // 输出: '1.2.3'
+const versionInfo = superAcmeVersion();
+console.log(versionInfo);
+// 在 SuperAcme 应用中可能输出：{ version: "1.2.3", major: 1, minor: 2, patch: 3 }
+// 在非 SuperAcme 应用中输出：{ version: "unknown" }
 ```
 
 ## 平台相关函数
@@ -211,6 +243,33 @@ if (userToken) {
 - 函数会对 Cookie 值进行解码，如果解码失败会捕获错误并返回 `null`。
 - 确保传入的 `name` 参数是合法的 Cookie 名称。
 
+### `getRUID()`
+
+获取当前域名下的 `RUID` 值。
+
+**返回值**: `string | null` - 返回当前域名下的 `RUID` 值，如果不存在或解析失败则返回 `null`
+
+**功能描述**:
+
+- 基于当前域名（`location.hostname`）动态生成 `RUID` 的 Cookie 名称。
+- 调用 `getCookie` 函数获取对应的 Cookie 值。
+
+**示例**:
+
+```typescript
+const ruid = getRUID();
+if (ruid) {
+  console.log(`RUID: ${ruid}`);
+} else {
+  console.log('RUID not found or invalid');
+}
+```
+
+**注意事项**:
+
+- 确保 `RUID` 的 Cookie 名称格式为 `RUID_<当前域名>`。
+- 函数依赖 `getCookie`，因此会继承其解码逻辑和错误处理机制。
+
 ## ARMS 模块
 
 `arms` 模块封装了阿里云 ARMS（应用实时监控服务）的前端监控功能，提供了一系列 API 用于上报性能数据、错误信息、用户行为等。

package/dist/esm/cookie.d.ts

@@ -1 +1,2 @@
 export declare function getCookie(name: string): string | null;
+export declare function getRUID(): string | null;

package/dist/esm/environment/factory.d.ts

@@ -0,0 +1,5 @@
+export declare class EnvironmentStrategyFactory {
+    private static strategies;
+    private static localStrategy;
+    static getStrategy(domain: string): EnvironmentStrategy;
+}

package/dist/esm/environment/factory.js

@@ -0,0 +1,31 @@
+// src/environment/factory.ts
+import { CinmooreEnvironmentStrategy } from "./strategies/cinmoore";
+import { LocalEnvironmentStrategy } from "./strategies/local";
+import { Safio365EnvironmentStrategy } from "./strategies/safio365";
+import { SensforgeEnvironmentStrategy } from "./strategies/sensforge";
+import { SuperAcmeEnvironmentStrategy } from "./strategies/superacme";
+var _EnvironmentStrategyFactory = class {
+  static getStrategy(domain) {
+    if (this.localStrategy.getEnvironment(domain) === "local") {
+      return this.localStrategy;
+    }
+    const strategy = this.strategies.get(domain);
+    if (!strategy) {
+      throw new Error(`Unsupported domain: ${domain}`);
+    }
+    return strategy;
+  }
+};
+var EnvironmentStrategyFactory = _EnvironmentStrategyFactory;
+EnvironmentStrategyFactory.strategies = /* @__PURE__ */ new Map();
+EnvironmentStrategyFactory.localStrategy = new LocalEnvironmentStrategy();
+(() => {
+  _EnvironmentStrategyFactory.strategies.set("superacme.com", new SuperAcmeEnvironmentStrategy());
+  _EnvironmentStrategyFactory.strategies.set("safio365.com", new Safio365EnvironmentStrategy());
+  _EnvironmentStrategyFactory.strategies.set("sensforge.com", new SensforgeEnvironmentStrategy());
+  _EnvironmentStrategyFactory.strategies.set("cinmoore.com", new CinmooreEnvironmentStrategy());
+  _EnvironmentStrategyFactory.strategies.set("cinmoore.cn", new CinmooreEnvironmentStrategy());
+})();
+export {
+  EnvironmentStrategyFactory
+};

package/dist/esm/environment/index.d.ts

@@ -0,0 +1,4 @@
+export declare const SUPPORTED_DOMAINS: string[];
+export declare function environment(): string;
+export declare function region(): string;
+export declare function isAWSDomain(): boolean;

package/dist/esm/environment/index.js

@@ -0,0 +1,59 @@
+// src/environment/index.ts
+import { EnvironmentStrategyFactory } from "./factory";
+var SUPPORTED_DOMAINS = [
+  "superacme.com",
+  "cinmoore.com",
+  "cinmoore.cn",
+  "safio365.com",
+  "sensforge.com",
+  "0.0.0.0",
+  "127.0.0.1",
+  "localhost"
+];
+function getCurrentDomain() {
+  if (typeof location === "undefined") {
+    throw new Error("location is not defined");
+  }
+  const host = location.host;
+  const domain = SUPPORTED_DOMAINS.find((d) => host.endsWith(d));
+  if (!domain) {
+    throw new Error(`Unsupported domain: ${host}`);
+  }
+  return domain;
+}
+function environment() {
+  try {
+    const domain = getCurrentDomain();
+    const strategy = EnvironmentStrategyFactory.getStrategy(domain);
+    return strategy.getEnvironment(location.host);
+  } catch (error) {
+    console.warn("Failed to determine environment:", error);
+    return "unknown";
+  }
+}
+function region() {
+  try {
+    const domain = getCurrentDomain();
+    const strategy = EnvironmentStrategyFactory.getStrategy(domain);
+    return strategy.getRegion(location.host);
+  } catch (error) {
+    console.warn("Failed to determine region:", error);
+    return "unknown";
+  }
+}
+function isAWSDomain() {
+  try {
+    const domain = getCurrentDomain();
+    const strategy = EnvironmentStrategyFactory.getStrategy(domain);
+    return strategy.isAWS(location.host);
+  } catch (error) {
+    console.warn("Failed to determine AWS domain:", error);
+    return false;
+  }
+}
+export {
+  SUPPORTED_DOMAINS,
+  environment,
+  isAWSDomain,
+  region
+};

package/dist/esm/environment/strategies/cinmoore.d.ts

@@ -0,0 +1,7 @@
+export declare class CinmooreEnvironmentStrategy implements EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    private readonly ENV_PATTERNS;
+    getEnvironment(host: string): string;
+    getRegion(): string;
+    isAWS(): boolean;
+}

package/dist/esm/environment/strategies/cinmoore.js

@@ -0,0 +1,42 @@
+// src/environment/strategies/cinmoore.ts
+var CinmooreEnvironmentStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+    this.ENV_PATTERNS = {
+      // 匹配 -dev、-dev1、-dev-1、-dev. 等
+      dev: /-dev(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -test、-test1、-test-1、-test. 等
+      test: /-test(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -pre、-pre1、-pre-1、-pre. 等
+      pre: /-pre(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -gray、-gray1、-gray-1、-gray. 等
+      gray: /-gray(?:\d*)?(?:-|\.|\b|$)/,
+      // 本地环境
+      local: /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?$/
+    };
+  }
+  getEnvironment(host) {
+    if (this.ENV_PATTERNS.local.test(host)) {
+      return "local";
+    }
+    for (const [env, pattern] of Object.entries(this.ENV_PATTERNS)) {
+      if (pattern.test(host)) {
+        return env;
+      }
+    }
+    return "prod";
+  }
+  getRegion() {
+    return "unknown";
+  }
+  isAWS() {
+    return false;
+  }
+};
+export {
+  CinmooreEnvironmentStrategy
+};

package/dist/esm/environment/strategies/local.d.ts

@@ -0,0 +1,7 @@
+export declare class LocalEnvironmentStrategy implements EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    private readonly LOCAL_PATTERN;
+    getEnvironment(host: string): string;
+    getRegion(): string;
+    isAWS(): boolean;
+}

package/dist/esm/environment/strategies/local.js

@@ -0,0 +1,23 @@
+// src/environment/strategies/local.ts
+var LocalEnvironmentStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+    this.LOCAL_PATTERN = /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?$/;
+  }
+  getEnvironment(host) {
+    return this.LOCAL_PATTERN.test(host) ? "local" : "unknown";
+  }
+  getRegion() {
+    return "unknown";
+  }
+  isAWS() {
+    return false;
+  }
+};
+export {
+  LocalEnvironmentStrategy
+};

package/dist/esm/environment/strategies/safio365.d.ts

@@ -0,0 +1,7 @@
+export declare class Safio365EnvironmentStrategy implements EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    private readonly ENV_PATTERNS;
+    getEnvironment(host: string): string;
+    getRegion(): string;
+    isAWS(): boolean;
+}

package/dist/esm/environment/strategies/safio365.js

@@ -0,0 +1,42 @@
+// src/environment/strategies/safio365.ts
+var Safio365EnvironmentStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+    this.ENV_PATTERNS = {
+      // 匹配 -dev、-dev1、-dev-1、-dev. 等
+      dev: /-dev(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -test、-test1、-test-1、-test. 等
+      test: /-test(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -pre、-pre1、-pre-1、-pre. 等
+      pre: /-pre(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -gray、-gray1、-gray-1、-gray. 等
+      gray: /-gray(?:\d*)?(?:-|\.|\b|$)/,
+      // 本地环境
+      local: /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?$/
+    };
+  }
+  getEnvironment(host) {
+    if (this.ENV_PATTERNS.local.test(host)) {
+      return "local";
+    }
+    for (const [env, pattern] of Object.entries(this.ENV_PATTERNS)) {
+      if (pattern.test(host)) {
+        return env;
+      }
+    }
+    return "prod";
+  }
+  getRegion() {
+    return "unknown";
+  }
+  isAWS() {
+    return false;
+  }
+};
+export {
+  Safio365EnvironmentStrategy
+};

package/dist/esm/environment/strategies/sensforge.d.ts

@@ -0,0 +1,7 @@
+export declare class SensforgeEnvironmentStrategy implements EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    private readonly ENV_PATTERNS;
+    getEnvironment(host: string): string;
+    getRegion(): string;
+    isAWS(): boolean;
+}

package/dist/esm/environment/strategies/sensforge.js

@@ -0,0 +1,42 @@
+// src/environment/strategies/sensforge.ts
+var SensforgeEnvironmentStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+    this.ENV_PATTERNS = {
+      // 匹配 -dev、-dev1、-dev-1、-dev. 等
+      dev: /-dev(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -test、-test1、-test-1、-test. 等
+      test: /-test(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -pre、-pre1、-pre-1、-pre. 等
+      pre: /-pre(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -gray、-gray1、-gray-1、-gray. 等
+      gray: /-gray(?:\d*)?(?:-|\.|\b|$)/,
+      // 本地环境
+      local: /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?$/
+    };
+  }
+  getEnvironment(host) {
+    if (this.ENV_PATTERNS.local.test(host)) {
+      return "local";
+    }
+    for (const [env, pattern] of Object.entries(this.ENV_PATTERNS)) {
+      if (pattern.test(host)) {
+        return env;
+      }
+    }
+    return "prod";
+  }
+  getRegion() {
+    return "unknown";
+  }
+  isAWS() {
+    return false;
+  }
+};
+export {
+  SensforgeEnvironmentStrategy
+};

package/dist/esm/environment/strategies/superacme.d.ts

@@ -0,0 +1,8 @@
+export declare class SuperAcmeEnvironmentStrategy implements EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    private readonly ENV_PATTERNS;
+    private readonly REGION_PATTERN;
+    getEnvironment(host: string): string;
+    getRegion(host: string): string;
+    isAWS(host: string): boolean;
+}

package/dist/esm/environment/strategies/superacme.js

@@ -0,0 +1,45 @@
+// src/environment/strategies/superacme.ts
+var SuperAcmeEnvironmentStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: true,
+      supportAWS: true
+    };
+    this.ENV_PATTERNS = {
+      // 匹配 -dev、-dev1、-dev-1、-dev.、-dev-aws 等
+      dev: /-dev(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -test、-test1、-test-1、-test.、-test-aws 等
+      test: /-test(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -pre、-pre1、-pre-1、-pre.、-pre-aws 等
+      pre: /-pre(?:\d*)?(?:-|\.|\b|$)/,
+      // 匹配 -gray、-gray1、-gray-1、-gray.、-gray-aws 等
+      gray: /-gray(?:\d*)?(?:-|\.|\b|$)/,
+      // 本地环境保持不变
+      local: /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(?::\d+)?$/
+    };
+    this.REGION_PATTERN = new RegExp("-(?<region>cn|us|usa|jpn|deu|gbr|fra|can|sgp|aus|kor|ind|bra|rus|zaf|mex|idn|tur|sau|che|twn|hkg|mac)(?=-|\\.|\\d|$)");
+  }
+  getEnvironment(host) {
+    if (this.ENV_PATTERNS.local.test(host)) {
+      return "local";
+    }
+    for (const [env, pattern] of Object.entries(this.ENV_PATTERNS)) {
+      if (pattern.test(host)) {
+        return env;
+      }
+    }
+    return "prod";
+  }
+  getRegion(host) {
+    var _a;
+    const match = host.match(this.REGION_PATTERN);
+    return ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.region) || "unknown";
+  }
+  isAWS(host) {
+    return host.includes("-aws");
+  }
+};
+export {
+  SuperAcmeEnvironmentStrategy
+};

package/dist/esm/gateway/factory.d.ts

@@ -0,0 +1,4 @@
+export declare class URLStrategyFactory {
+    private static strategies;
+    static getStrategy(domain: string): URLStrategy;
+}

package/dist/esm/gateway/factory.js

@@ -0,0 +1,25 @@
+// src/gateway/factory.ts
+import {
+  Safio365URLStrategy,
+  SensforgeURLStrategy,
+  SuperAcmeURLStrategy
+} from "./strategies/index";
+var _URLStrategyFactory = class {
+  static getStrategy(domain) {
+    const strategy = this.strategies.get(domain);
+    if (!strategy) {
+      throw new Error(`Unsupported domain: ${domain}`);
+    }
+    return strategy;
+  }
+};
+var URLStrategyFactory = _URLStrategyFactory;
+URLStrategyFactory.strategies = /* @__PURE__ */ new Map();
+(() => {
+  _URLStrategyFactory.strategies.set("superacme.com", new SuperAcmeURLStrategy());
+  _URLStrategyFactory.strategies.set("sensforge.com", new SensforgeURLStrategy());
+  _URLStrategyFactory.strategies.set("safio365.com", new Safio365URLStrategy());
+})();
+export {
+  URLStrategyFactory
+};

package/dist/esm/gateway/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 根据当前域名生成基于 name 和 path 的 baseUrl
+ *
+ * @param params 配置参数
+ * @param params.name - 必填，API 服务名称（例如：'api', 'iot-api'）
+ * @param params.path - 可选，API 路径（例如：'/saas'）
+ * @returns 生成的 URL。如果生成失败则返回传入的 path 值
+ *
+ * @example
+ * // SuperAcme 域名系列
+ * // 中国区开发环境
+ * baseUrl({ name: 'api' }) // => '//api-cn-dev.superacme.com'
+ * baseUrl({ name: 'iot-api', path: '/saas' }) // => '//iot-api-cn-dev.superacme.com/saas'
+ *
+ * // 美区 AWS 环境
+ * // location.host: 'mall-us-aws.superacme.com'
+ * baseUrl({ name: 'api' }) // => '//api-us-aws.superacme.com'
+ *
+ * // Safio365 域名系列
+ * // location.host: 'iot-dev.safio365.com'
+ * baseUrl({ name: 'iot-api', path: '/saas' }) // => '//iot-api-dev.safio365.com/saas'
+ *
+ * // Sensforge 域名系列
+ * // location.host: 'api-dev.sensforge.com'
+ * baseUrl({ name: 'iot-api' }) // => '//iot-api-dev.sensforge.com'
+ *
+ * @throws 如果 name 参数为空，将抛出错误并返回 path
+ * @throws 如果域名不在支持列表中，将返回 path
+ */
+export declare function baseUrl(params: {
+    name: string;
+    path?: string;
+}): string | undefined;

package/dist/esm/gateway/index.js

@@ -0,0 +1,44 @@
+// src/gateway/index.ts
+import { environment, isAWSDomain, region, SUPPORTED_DOMAINS } from "../environment/index";
+import { URLStrategyFactory } from "./factory";
+function getCurrentDomain() {
+  const host = location.host;
+  const domain = SUPPORTED_DOMAINS.find((domain2) => host.endsWith(domain2));
+  if (!domain) {
+    throw new Error(`Unsupported domain: ${host}`);
+  }
+  return domain;
+}
+function baseUrl(params) {
+  try {
+    if (!params.name) {
+      throw new Error("name parameter is required");
+    }
+    const domain = getCurrentDomain();
+    const strategy = URLStrategyFactory.getStrategy(domain);
+    const urlParams = {
+      name: params.name,
+      path: params.path || ""
+    };
+    if (strategy.features.supportEnv) {
+      const env = environment();
+      if (env === "unknown") {
+        return params.path;
+      }
+      urlParams.env = env;
+    }
+    if (strategy.features.supportRegion) {
+      urlParams.region = region();
+    }
+    if (strategy.features.supportAWS) {
+      urlParams.isAWS = isAWSDomain();
+    }
+    return strategy.generateURL(urlParams);
+  } catch (error) {
+    console.warn("Failed to generate base URL:", error);
+    return params.path;
+  }
+}
+export {
+  baseUrl
+};

package/dist/esm/gateway/strategies/index.d.ts

@@ -0,0 +1,3 @@
+export * from './safio365';
+export * from './sensforge';
+export * from './superacme';

package/dist/esm/gateway/strategies/index.js

@@ -0,0 +1,4 @@
+// src/gateway/strategies/index.ts
+export * from "./safio365";
+export * from "./sensforge";
+export * from "./superacme";

package/dist/esm/gateway/strategies/safio365.d.ts

@@ -0,0 +1,4 @@
+export declare class Safio365URLStrategy implements URLStrategy {
+    features: DomainFeatures;
+    generateURL({ name, env, path }: URLStrategyConfig): string;
+}

package/dist/esm/gateway/strategies/safio365.js

@@ -0,0 +1,19 @@
+// src/gateway/strategies/safio365.ts
+var Safio365URLStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+  }
+  generateURL({ name, env = "prod", path = "" }) {
+    if (env === "prod" || !env) {
+      return `//${name}.safio365.com${path}`;
+    }
+    return `//${name}-${env}.safio365.com${path}`;
+  }
+};
+export {
+  Safio365URLStrategy
+};

package/dist/esm/gateway/strategies/sensforge.d.ts

@@ -0,0 +1,4 @@
+export declare class SensforgeURLStrategy implements URLStrategy {
+    features: DomainFeatures;
+    generateURL({ name, env, path }: URLStrategyConfig): string;
+}

package/dist/esm/gateway/strategies/sensforge.js

@@ -0,0 +1,19 @@
+// src/gateway/strategies/sensforge.ts
+var SensforgeURLStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: false,
+      supportAWS: false
+    };
+  }
+  generateURL({ name, env = "prod", path = "" }) {
+    if (env === "prod" || !env) {
+      return `//${name}.sensforge.com${path}`;
+    }
+    return `//${name}-${env}.sensforge.com${path}`;
+  }
+};
+export {
+  SensforgeURLStrategy
+};

package/dist/esm/gateway/strategies/superacme.d.ts

@@ -0,0 +1,4 @@
+export declare class SuperAcmeURLStrategy implements URLStrategy {
+    features: DomainFeatures;
+    generateURL({ name, env, region, isAWS, path, }: URLStrategyConfig): string;
+}

package/dist/esm/gateway/strategies/superacme.js

@@ -0,0 +1,27 @@
+// src/gateway/strategies/superacme.ts
+var SuperAcmeURLStrategy = class {
+  constructor() {
+    this.features = {
+      supportEnv: true,
+      supportRegion: true,
+      supportAWS: true
+    };
+  }
+  generateURL({
+    name,
+    env = "prod",
+    region = "",
+    isAWS = false,
+    path = ""
+  }) {
+    const regionPart = region ? `-${region}` : "";
+    const awsPart = isAWS ? "-aws" : "";
+    if (env === "prod" || !env) {
+      return `//${name}${regionPart}${awsPart}.superacme.com${path}`;
+    }
+    return `//${name}${regionPart}-${env}${awsPart}.superacme.com${path}`;
+  }
+};
+export {
+  SuperAcmeURLStrategy
+};

package/dist/esm/global.d.ts

@@ -39,6 +39,43 @@ declare global {
       addBehavior(data: { name: string; message: string }, page: string): void;
     };
   }
+
+  type URLStrategyConfig = {
+    name: string;
+    env?: string;
+    region?: string;
+    isAWS?: boolean;
+    path?: string;
+  };
+
+  interface DomainFeatures {
+    supportEnv: boolean;
+    supportRegion: boolean;
+    supportAWS: boolean;
+  }
+  interface URLStrategy {
+    features: DomainFeatures;
+    generateURL(params: URLStrategyConfig): string;
+  }
+
+  interface EnvironmentFeatures {
+    supportEnv: boolean; // 是否支持环境判断
+    supportRegion: boolean; // 是否支持区域判断
+    supportAWS: boolean; // 是否支持 AWS 判断
+  }
+
+  interface EnvironmentStrategy {
+    features: EnvironmentFeatures;
+    getEnvironment(host: string): string;
+    getRegion(host: string): string;
+    isAWS(host: string): boolean;
+  }
+
+  interface EnvironmentConfig {
+    env?: string;
+    region?: string;
+    isAWS?: boolean;
+  }
 }
 
 export {};

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 export * from './arms';
 export * from './cookie';
-export * from './environment';
-export * from './gateway';
+export * from './environment/index';
+export * from './gateway/index';
 export * from './hybrid';
 export * from './local';
 export * from './platform';

package/dist/esm/index.js

@@ -1,8 +1,8 @@
 // src/index.ts
 export * from "./arms";
 export * from "./cookie";
-export * from "./environment";
-export * from "./gateway";
+export * from "./environment/index";
+export * from "./gateway/index";
 export * from "./hybrid";
 export * from "./local";
 export * from "./platform";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microbt/environment",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "microbt app library for environment",
   "keywords": [],
   "license": "MIT",

package/dist/esm/environment.d.ts

@@ -1,15 +0,0 @@
-/**
- * 获取当前运行的环境
- * @returns {string} 环境名称（local, dev, test, pre, gray, prod, unknown）
- */
-export declare const environment: () => string;
-/**
- * 获取当前运行的区域
- * @returns {string} 区域名称（如 cn, us 等）
- */
-export declare const region: () => string;
-/**
- * 判断当前域名是否为 AWS 域名
- * @returns {boolean} 是否为 AWS 域名
- */
-export declare function isAWSDomain(): boolean;

package/dist/esm/gateway.d.ts

@@ -1 +0,0 @@
-export declare function baseUrl(): string | undefined;