request-iframe 0.0.1

package/library/utils/path-match.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Path matcher type
+ */
+export type PathMatcher = string | RegExp | PathPattern | Array<string | RegExp | PathPattern>;
+/**
+ * Path pattern (supports wildcards)
+ * Example: '/api/*' matches all paths starting with '/api/'
+ */
+export type PathPattern = string;
+/**
+ * Check if path matches the given matcher
+ * @param path request path
+ * @param matcher path matcher (string, RegExp, PathPattern, or array)
+ * @returns whether matches
+ */
+export declare function matchPath(path: string, matcher: PathMatcher): boolean;
+//# sourceMappingURL=path-match.d.ts.map

package/library/utils/path-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-match.d.ts","sourceRoot":"","sources":["../../src/utils/path-match.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;AAE/F;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CA+CrE"}

package/library/utils/path-match.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matchPath = matchPath;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.ends-with.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/es.string.starts-with.js");
+/**
+ * Path matcher type
+ */
+
+/**
+ * Path pattern (supports wildcards)
+ * Example: '/api/*' matches all paths starting with '/api/'
+ */
+
+/**
+ * Check if path matches the given matcher
+ * @param path request path
+ * @param matcher path matcher (string, RegExp, PathPattern, or array)
+ * @returns whether matches
+ */
+function matchPath(path, matcher) {
+  // Normalize path (ensure starts with /)
+  var normalizedPath = path.startsWith('/') ? path : `/${path}`;
+
+  // If array, match if any one matches
+  if (Array.isArray(matcher)) {
+    return matcher.some(m => matchPath(normalizedPath, m));
+  }
+
+  // If RegExp
+  if (matcher instanceof RegExp) {
+    return matcher.test(normalizedPath);
+  }
+
+  // If string
+  if (typeof matcher === 'string') {
+    // Exact match
+    if (normalizedPath === matcher) {
+      return true;
+    }
+
+    // Normalize matcher (ensure starts with /)
+    var normalizedMatcher = matcher.startsWith('/') ? matcher : `/${matcher}`;
+
+    // Prefix match
+    if (normalizedPath.startsWith(normalizedMatcher)) {
+      // If matcher is '/api', path is '/api', match
+      // If matcher is '/api', path is '/api/users', match
+      // If matcher is '/api/', path is '/api/users', match
+      // If matcher is '/api', path is '/api2', no match
+      if (normalizedMatcher.endsWith('/')) {
+        return true;
+      }
+      // If matcher doesn't end with /, ensure path has / or ends after matcher
+      var nextChar = normalizedPath[normalizedMatcher.length];
+      return nextChar === undefined || nextChar === '/';
+    }
+
+    // Support wildcard patterns (e.g., '/api/*')
+    if (matcher.includes('*')) {
+      return matchPattern(normalizedPath, normalizedMatcher);
+    }
+    return false;
+  }
+  return false;
+}
+
+/**
+ * Match path pattern (supports wildcards)
+ * @param path request path
+ * @param pattern path pattern (e.g., '/api/*')
+ */
+function matchPattern(path, pattern) {
+  // Convert pattern to regex
+  // '/api/*' -> '^/api/.*$'
+  // '/api/*/users' -> '^/api/.*/users$'
+  var regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special characters
+  .replace(/\*/g, '.*'); // Replace * with .*
+  var regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}

package/library/utils/protocol.d.ts

@@ -0,0 +1,61 @@
+import { PostMessageData } from '../types';
+import { ProtocolValidationResult } from '../constants';
+/**
+ * Validate protocol version
+ *
+ * Only checks minimum supported version, not maximum version
+ * Because new versions usually maintain backward compatibility with older message formats
+ *
+ * @param version protocol version number
+ * @returns validation result
+ */
+export declare function validateProtocolVersion(version: number): ProtocolValidationResult;
+/**
+ * Validate PostMessage data format (full validation)
+ * @param data data to validate
+ * @returns validation result, including protocol version info
+ */
+export declare function validatePostMessage(data: any): ProtocolValidationResult & {
+    data?: PostMessageData;
+};
+/**
+ * Check if data is a request-iframe framework message (only checks basic format, doesn't validate version compatibility)
+ * @param data data to check
+ * @returns whether it's a request-iframe message
+ */
+export declare function isRequestIframeMessage(data: any): boolean;
+/**
+ * Create PostMessage data
+ * @param type message type
+ * @param requestId request ID
+ * @param data additional data
+ * @returns PostMessageData
+ */
+export declare function createPostMessage(type: PostMessageData['type'], requestId: string, data?: Partial<Omit<PostMessageData, '__requestIframe__' | 'type' | 'requestId' | 'timestamp'>>): PostMessageData;
+/**
+ * Validate PostMessage data format (only checks basic format, doesn't validate version compatibility)
+ * Used for quick determination of whether it's a request-iframe framework message
+ *
+ * Note: This method doesn't check protocol version compatibility, use isCompatibleVersion for version compatibility check
+ *
+ * @param data data to validate
+ * @returns whether it's a valid PostMessageData
+ */
+export declare function isValidPostMessage(data: any): data is PostMessageData;
+/**
+ * Get protocol version from message
+ * @param data PostMessageData
+ * @returns protocol version number, undefined if invalid
+ */
+export declare function getProtocolVersion(data: any): number | undefined;
+/**
+ * Check if protocol version is compatible
+ *
+ * Only checks minimum supported version, not maximum version
+ * Because new versions usually maintain backward compatibility with older message formats
+ *
+ * @param version protocol version number
+ * @returns whether compatible
+ */
+export declare function isCompatibleVersion(version: number): boolean;
+//# sourceMappingURL=protocol.d.ts.map

package/library/utils/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/utils/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAmB,wBAAwB,EAA2B,MAAM,cAAc,CAAC;AAElG;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,wBAAwB,CAuBjF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,GAAG,GAAG,wBAAwB,GAAG;IAAE,IAAI,CAAC,EAAE,eAAe,CAAA;CAAE,CAiDpG;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAQzD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,EAC7B,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,mBAAmB,GAAG,MAAM,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC,GAC9F,eAAe,CAQjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,IAAI,eAAe,CAQrE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAKhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D"}

package/library/utils/protocol.js

@@ -0,0 +1,169 @@
+"use strict";
+
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPostMessage = createPostMessage;
+exports.getProtocolVersion = getProtocolVersion;
+exports.isCompatibleVersion = isCompatibleVersion;
+exports.isRequestIframeMessage = isRequestIframeMessage;
+exports.isValidPostMessage = isValidPostMessage;
+exports.validatePostMessage = validatePostMessage;
+exports.validateProtocolVersion = validateProtocolVersion;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("../constants");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Validate protocol version
+ * 
+ * Only checks minimum supported version, not maximum version
+ * Because new versions usually maintain backward compatibility with older message formats
+ * 
+ * @param version protocol version number
+ * @returns validation result
+ */
+function validateProtocolVersion(version) {
+  if (typeof version !== 'number' || !Number.isInteger(version)) {
+    return {
+      valid: false,
+      error: _constants.Messages.INVALID_PROTOCOL_VERSION_FORMAT,
+      errorCode: 'INVALID_FORMAT'
+    };
+  }
+  if (version < _constants.ProtocolVersion.MIN_SUPPORTED) {
+    return {
+      valid: false,
+      version,
+      error: (0, _constants.formatMessage)(_constants.Messages.PROTOCOL_VERSION_TOO_LOW, version, _constants.ProtocolVersion.MIN_SUPPORTED),
+      errorCode: 'VERSION_TOO_LOW'
+    };
+  }
+
+  // Don't check maximum version, new versions usually maintain backward compatibility
+  return {
+    valid: true,
+    version
+  };
+}
+
+/**
+ * Validate PostMessage data format (full validation)
+ * @param data data to validate
+ * @returns validation result, including protocol version info
+ */
+function validatePostMessage(data) {
+  // Basic format validation
+  if (!data || typeof data !== 'object') {
+    return {
+      valid: false,
+      error: _constants.Messages.INVALID_MESSAGE_FORMAT_NOT_OBJECT,
+      errorCode: 'INVALID_FORMAT'
+    };
+  }
+
+  // Protocol identifier validation
+  if (data.__requestIframe__ === undefined) {
+    return {
+      valid: false,
+      error: _constants.Messages.INVALID_MESSAGE_FORMAT_MISSING_PROTOCOL,
+      errorCode: 'INVALID_FORMAT'
+    };
+  }
+
+  // Protocol version validation
+  var versionResult = validateProtocolVersion(data.__requestIframe__);
+  if (!versionResult.valid) {
+    return versionResult;
+  }
+
+  // Required field validation
+  if (typeof data.type !== 'string') {
+    return {
+      valid: false,
+      version: versionResult.version,
+      error: _constants.Messages.INVALID_MESSAGE_FORMAT_MISSING_TYPE,
+      errorCode: 'INVALID_FORMAT'
+    };
+  }
+  if (typeof data.requestId !== 'string') {
+    return {
+      valid: false,
+      version: versionResult.version,
+      error: _constants.Messages.INVALID_MESSAGE_FORMAT_MISSING_REQUEST_ID,
+      errorCode: 'INVALID_FORMAT'
+    };
+  }
+  return {
+    valid: true,
+    version: versionResult.version,
+    data: data
+  };
+}
+
+/**
+ * Check if data is a request-iframe framework message (only checks basic format, doesn't validate version compatibility)
+ * @param data data to check
+ * @returns whether it's a request-iframe message
+ */
+function isRequestIframeMessage(data) {
+  return !!(data && typeof data === 'object' && typeof data.__requestIframe__ === 'number' && typeof data.type === 'string' && typeof data.requestId === 'string');
+}
+
+/**
+ * Create PostMessage data
+ * @param type message type
+ * @param requestId request ID
+ * @param data additional data
+ * @returns PostMessageData
+ */
+function createPostMessage(type, requestId, data) {
+  return _objectSpread({
+    __requestIframe__: _constants.ProtocolVersion.CURRENT,
+    timestamp: Date.now(),
+    type,
+    requestId
+  }, data);
+}
+
+/**
+ * Validate PostMessage data format (only checks basic format, doesn't validate version compatibility)
+ * Used for quick determination of whether it's a request-iframe framework message
+ * 
+ * Note: This method doesn't check protocol version compatibility, use isCompatibleVersion for version compatibility check
+ * 
+ * @param data data to validate
+ * @returns whether it's a valid PostMessageData
+ */
+function isValidPostMessage(data) {
+  return !!(data && typeof data === 'object' && typeof data.__requestIframe__ === 'number' && typeof data.type === 'string' && typeof data.requestId === 'string');
+}
+
+/**
+ * Get protocol version from message
+ * @param data PostMessageData
+ * @returns protocol version number, undefined if invalid
+ */
+function getProtocolVersion(data) {
+  if (data && typeof data === 'object' && typeof data.__requestIframe__ === 'number') {
+    return data.__requestIframe__;
+  }
+  return undefined;
+}
+
+/**
+ * Check if protocol version is compatible
+ * 
+ * Only checks minimum supported version, not maximum version
+ * Because new versions usually maintain backward compatibility with older message formats
+ * 
+ * @param version protocol version number
+ * @returns whether compatible
+ */
+function isCompatibleVersion(version) {
+  return version >= _constants.ProtocolVersion.MIN_SUPPORTED;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "request-iframe",
+  "version": "0.0.1",
+  "description": "Communicate with iframes like sending HTTP requests",
+  "main": "library/index.js",
+  "types": "library/index.d.ts",
+  "scripts": {
+    "build": "npm run build:types && npm run build:js",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:js": "babel src --out-dir library --extensions .ts --copy-files",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "library",
+    "README.md",
+    "README.CN.md",
+    "QUICKSTART.md",
+    "QUICKSTART.CN.md"
+  ],
+  "keywords": [
+    "iframe",
+    "postMessage",
+    "request",
+    "axios"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gxlmyacc/request-iframe"
+  },
+  "author": "gxlmyacc",
+  "license": "MIT",
+  "dependencies": {
+    "core-js": "^3.48.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.28.6",
+    "@babel/plugin-transform-runtime": "^7.28.5",
+    "@babel/preset-env": "^7.28.6",
+    "@babel/preset-typescript": "^7.28.5",
+    "@babel/runtime": "^7.28.6",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "coveralls": "^3.1.1",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  }
+}