@usertour/helpers 0.0.2 → 0.0.3

package/dist/chunk-JQ4E3IDB.js

@@ -0,0 +1,112 @@
+import {
+  __publicField
+} from "./chunk-XEO3YXBM.js";
+
+// src/jwt-license-signer.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as jwt from "jsonwebtoken";
+var JWTLicenseSigner = class {
+  constructor(options) {
+    __publicField(this, "privateKey");
+    __publicField(this, "issuer");
+    __publicField(this, "algorithm");
+    this.privateKey = this.loadPrivateKey(options.privateKeyPath);
+    this.issuer = options.issuer || "https://www.usertour.io";
+    this.algorithm = options.algorithm || "RS256";
+  }
+  /**
+   * Load RSA private key from file
+   */
+  loadPrivateKey(keyPath) {
+    try {
+      const fullPath = path.resolve(keyPath);
+      return fs.readFileSync(fullPath, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to load private key from ${keyPath}: ${error}`);
+    }
+  }
+  /**
+   * Generate a JWT license token
+   */
+  generateLicense(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
+    const payload = {
+      plan: options.plan,
+      sub: options.subject,
+      projectId: options.projectId,
+      iat: now,
+      exp: expiresAt,
+      issuer: options.issuer || this.issuer,
+      features: options.features
+    };
+    try {
+      return jwt.sign(payload, this.privateKey, {
+        algorithm: this.algorithm,
+        issuer: this.issuer
+      });
+    } catch (error) {
+      throw new Error(`Failed to generate JWT license: ${error}`);
+    }
+  }
+  /**
+   * Generate a license and return both token and payload info
+   */
+  generateLicenseWithInfo(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
+    const payload = {
+      plan: options.plan,
+      sub: options.subject,
+      projectId: options.projectId,
+      iat: now,
+      exp: expiresAt,
+      issuer: options.issuer || this.issuer,
+      features: options.features
+    };
+    const token = jwt.sign(payload, this.privateKey, {
+      algorithm: this.algorithm,
+      issuer: this.issuer
+    });
+    return {
+      token,
+      payload,
+      expiresAt: new Date(expiresAt * 1e3)
+    };
+  }
+  /**
+   * Decode a JWT token without verification (for debugging)
+   */
+  decodeToken(token) {
+    try {
+      return jwt.decode(token);
+    } catch (error) {
+      console.error("Failed to decode JWT token:", error);
+      return null;
+    }
+  }
+  /**
+   * Get token information without verification
+   */
+  getTokenInfo(token) {
+    try {
+      const decoded = jwt.decode(token, { complete: true });
+      if (!decoded || typeof decoded === "string") {
+        return null;
+      }
+      return {
+        header: decoded.header,
+        payload: decoded.payload,
+        signature: decoded.signature
+      };
+    } catch (error) {
+      console.error("Failed to get token info:", error);
+      return null;
+    }
+  }
+};
+
+export {
+  JWTLicenseSigner
+};

package/dist/chunk-KJJ6UD5L.js

@@ -0,0 +1,183 @@
+// src/jwt-license-validator.ts
+import * as jwt from "jsonwebtoken";
+var JWTLicenseValidator = {
+  /**
+   * Validate a JWT license
+   * @param license - JWT license string
+   * @param publicKey - RSA public key in PEM format
+   * @param options - Validation options
+   * @returns Validation result
+   */
+  validateLicense(license, publicKey, options = {}) {
+    try {
+      const { checkExpiration = true, currentTime = /* @__PURE__ */ new Date() } = options;
+      const decoded = jwt.verify(license, publicKey, {
+        algorithms: ["RS256"],
+        ignoreExpiration: !checkExpiration
+      });
+      const fieldValidation = this.validateRequiredFields(decoded);
+      if (!fieldValidation.isValid) {
+        return fieldValidation;
+      }
+      if (checkExpiration) {
+        const expirationValidation = this.checkExpiration(decoded, currentTime);
+        if (!expirationValidation.isValid) {
+          return expirationValidation;
+        }
+      }
+      const hasFeature = (feature) => {
+        return decoded.features.includes("*") || decoded.features.includes(feature);
+      };
+      return {
+        isValid: true,
+        payload: decoded,
+        isExpired: false,
+        hasFeature
+      };
+    } catch (error) {
+      if (error instanceof jwt.JsonWebTokenError) {
+        return {
+          isValid: false,
+          error: `JWT validation failed: ${error.message}`
+        };
+      }
+      if (error instanceof jwt.TokenExpiredError) {
+        return {
+          isValid: false,
+          error: `License expired: ${error.message}`,
+          isExpired: true
+        };
+      }
+      return {
+        isValid: false,
+        error: `License validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  },
+  /**
+   * Validate that all required fields are present in license payload
+   * @param payload - License payload to validate
+   * @returns Validation result
+   */
+  validateRequiredFields(payload) {
+    const requiredFields = ["plan", "sub", "projectId", "iat", "exp", "issuer", "features"];
+    for (const field of requiredFields) {
+      if (!(field in payload)) {
+        return {
+          isValid: false,
+          error: `Missing required field: ${field}`
+        };
+      }
+    }
+    if (typeof payload.plan !== "string" || !payload.plan.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid plan: must be a non-empty string"
+      };
+    }
+    if (typeof payload.sub !== "string" || !payload.sub.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid sub: must be a non-empty string"
+      };
+    }
+    if (typeof payload.projectId !== "string" || !payload.projectId.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid projectId: must be a non-empty string"
+      };
+    }
+    if (typeof payload.issuer !== "string" || !payload.issuer.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid issuer: must be a non-empty string"
+      };
+    }
+    if (!Array.isArray(payload.features)) {
+      return {
+        isValid: false,
+        error: "Invalid features: must be an array"
+      };
+    }
+    if (typeof payload.iat !== "number" || payload.iat <= 0) {
+      return {
+        isValid: false,
+        error: "Invalid iat: must be a positive number"
+      };
+    }
+    if (typeof payload.exp !== "number" || payload.exp <= 0) {
+      return {
+        isValid: false,
+        error: "Invalid exp: must be a positive number"
+      };
+    }
+    if (payload.iat >= payload.exp) {
+      return {
+        isValid: false,
+        error: "Invalid timestamps: iat must be before exp"
+      };
+    }
+    return { isValid: true };
+  },
+  /**
+   * Check if license has expired
+   * @param payload - License payload
+   * @param currentTime - Current time to check against (defaults to now)
+   * @returns Validation result
+   */
+  checkExpiration(payload, currentTime = /* @__PURE__ */ new Date()) {
+    const now = Math.floor(currentTime.getTime() / 1e3);
+    const expiresAt = payload.exp;
+    if (now > expiresAt) {
+      return {
+        isValid: false,
+        error: `License expired on ${new Date(expiresAt * 1e3).toISOString()}`,
+        isExpired: true
+      };
+    }
+    return { isValid: true, isExpired: false };
+  },
+  /**
+   * Check if license has a specific feature
+   * @param payload - License payload
+   * @param feature - Feature to check
+   * @returns Whether the feature is available
+   */
+  hasFeature(payload, feature) {
+    return payload.features.includes("*") || payload.features.includes(feature);
+  },
+  /**
+   * Get license expiration status
+   * @param payload - License payload
+   * @param currentTime - Current time to check against (defaults to now)
+   * @returns Expiration information
+   */
+  getExpirationInfo(payload, currentTime = /* @__PURE__ */ new Date()) {
+    const now = Math.floor(currentTime.getTime() / 1e3);
+    const expiresAt = payload.exp;
+    const isExpired = now > expiresAt;
+    const daysUntilExpiration = Math.ceil((expiresAt - now) / (24 * 60 * 60));
+    return {
+      isExpired,
+      expiresAt: new Date(expiresAt * 1e3),
+      daysUntilExpiration: isExpired ? 0 : daysUntilExpiration
+    };
+  },
+  /**
+   * Decode JWT license without verification (for debugging)
+   * @param license - JWT license string
+   * @returns Decoded payload or null if invalid
+   */
+  decodeLicense(license) {
+    try {
+      const decoded = jwt.decode(license);
+      return decoded;
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  JWTLicenseValidator
+};

package/dist/index.cjs

@@ -37,6 +37,8 @@ var src_exports = {};
 __export(src_exports, {
   AbortController: () => AbortController,
   ArrayProto: () => ArrayProto,
+  JWTLicenseSigner: () => JWTLicenseSigner,
+  JWTLicenseValidator: () => JWTLicenseValidator,
   XMLHttpRequest: () => XMLHttpRequest,
   absoluteUrl: () => absoluteUrl,
   assignableWindow: () => assignableWindow,
@@ -448,8 +450,8 @@ var parseUrl = (url) => {
   if (!urlPatterns) {
     return null;
   }
-  const [, , scheme = "", domain = "", path = "", , query = "", fragment = ""] = urlPatterns;
-  return { scheme, domain, path, query, fragment };
+  const [, , scheme = "", domain = "", path2 = "", , query = "", fragment = ""] = urlPatterns;
+  return { scheme, domain, path: path2, query, fragment };
 };
 var replaceWildcard = (input, s1, s2) => {
   const withSpecialWords = replaceSpecialWords(input);
@@ -471,11 +473,11 @@ var parsePattern = (pattern) => {
     console.error("Invalid URL pattern:", pattern);
     return null;
   }
-  const { scheme, domain, path, query, fragment } = _pattern;
+  const { scheme, domain, path: path2, query, fragment } = _pattern;
   const _scheme = scheme ? replaceSpecialWords(scheme) : "[a-z\\d]+";
   const _domain = domain ? replaceWildcard(domain, "[^/]", ".") : "[^/]*";
   const _fragment = fragment ? replaceWildcard(fragment, ".", "/") : "(#.*)?";
-  const _path = path ? replaceWildcard(path, "[^?#]", "/") : "/[^?#]*";
+  const _path = path2 ? replaceWildcard(path2, "[^?#]", "/") : "/[^?#]*";
   let _query = "(\\?[^#]*)?";
   if (query) {
     new URLSearchParams(query).forEach((value, key) => {
@@ -1038,8 +1040,8 @@ function formatDate(input) {
     year: "numeric"
   });
 }
-function absoluteUrl(path) {
-  return `${path}`;
+function absoluteUrl(path2) {
+  return `${path2}`;
 }
 var uuidV4 = () => {
   return (0, import_uuid.v4)();
@@ -1086,10 +1088,297 @@ var getRandomColor = () => {
   ];
   return colors[Math.floor(Math.random() * colors.length)];
 };
+
+// src/jwt-license-signer.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var jwt = __toESM(require("jsonwebtoken"), 1);
+var JWTLicenseSigner = class {
+  constructor(options) {
+    __publicField(this, "privateKey");
+    __publicField(this, "issuer");
+    __publicField(this, "algorithm");
+    this.privateKey = this.loadPrivateKey(options.privateKeyPath);
+    this.issuer = options.issuer || "https://www.usertour.io";
+    this.algorithm = options.algorithm || "RS256";
+  }
+  /**
+   * Load RSA private key from file
+   */
+  loadPrivateKey(keyPath) {
+    try {
+      const fullPath = path.resolve(keyPath);
+      return fs.readFileSync(fullPath, "utf8");
+    } catch (error) {
+      throw new Error(`Failed to load private key from ${keyPath}: ${error}`);
+    }
+  }
+  /**
+   * Generate a JWT license token
+   */
+  generateLicense(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
+    const payload = {
+      plan: options.plan,
+      sub: options.subject,
+      projectId: options.projectId,
+      iat: now,
+      exp: expiresAt,
+      issuer: options.issuer || this.issuer,
+      features: options.features
+    };
+    try {
+      return jwt.sign(payload, this.privateKey, {
+        algorithm: this.algorithm,
+        issuer: this.issuer
+      });
+    } catch (error) {
+      throw new Error(`Failed to generate JWT license: ${error}`);
+    }
+  }
+  /**
+   * Generate a license and return both token and payload info
+   */
+  generateLicenseWithInfo(options) {
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
+    const payload = {
+      plan: options.plan,
+      sub: options.subject,
+      projectId: options.projectId,
+      iat: now,
+      exp: expiresAt,
+      issuer: options.issuer || this.issuer,
+      features: options.features
+    };
+    const token = jwt.sign(payload, this.privateKey, {
+      algorithm: this.algorithm,
+      issuer: this.issuer
+    });
+    return {
+      token,
+      payload,
+      expiresAt: new Date(expiresAt * 1e3)
+    };
+  }
+  /**
+   * Decode a JWT token without verification (for debugging)
+   */
+  decodeToken(token) {
+    try {
+      return jwt.decode(token);
+    } catch (error) {
+      console.error("Failed to decode JWT token:", error);
+      return null;
+    }
+  }
+  /**
+   * Get token information without verification
+   */
+  getTokenInfo(token) {
+    try {
+      const decoded = jwt.decode(token, { complete: true });
+      if (!decoded || typeof decoded === "string") {
+        return null;
+      }
+      return {
+        header: decoded.header,
+        payload: decoded.payload,
+        signature: decoded.signature
+      };
+    } catch (error) {
+      console.error("Failed to get token info:", error);
+      return null;
+    }
+  }
+};
+
+// src/jwt-license-validator.ts
+var jwt2 = __toESM(require("jsonwebtoken"), 1);
+var JWTLicenseValidator = {
+  /**
+   * Validate a JWT license
+   * @param license - JWT license string
+   * @param publicKey - RSA public key in PEM format
+   * @param options - Validation options
+   * @returns Validation result
+   */
+  validateLicense(license, publicKey, options = {}) {
+    try {
+      const { checkExpiration = true, currentTime = /* @__PURE__ */ new Date() } = options;
+      const decoded = jwt2.verify(license, publicKey, {
+        algorithms: ["RS256"],
+        ignoreExpiration: !checkExpiration
+      });
+      const fieldValidation = this.validateRequiredFields(decoded);
+      if (!fieldValidation.isValid) {
+        return fieldValidation;
+      }
+      if (checkExpiration) {
+        const expirationValidation = this.checkExpiration(decoded, currentTime);
+        if (!expirationValidation.isValid) {
+          return expirationValidation;
+        }
+      }
+      const hasFeature = (feature) => {
+        return decoded.features.includes("*") || decoded.features.includes(feature);
+      };
+      return {
+        isValid: true,
+        payload: decoded,
+        isExpired: false,
+        hasFeature
+      };
+    } catch (error) {
+      if (error instanceof jwt2.JsonWebTokenError) {
+        return {
+          isValid: false,
+          error: `JWT validation failed: ${error.message}`
+        };
+      }
+      if (error instanceof jwt2.TokenExpiredError) {
+        return {
+          isValid: false,
+          error: `License expired: ${error.message}`,
+          isExpired: true
+        };
+      }
+      return {
+        isValid: false,
+        error: `License validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  },
+  /**
+   * Validate that all required fields are present in license payload
+   * @param payload - License payload to validate
+   * @returns Validation result
+   */
+  validateRequiredFields(payload) {
+    const requiredFields = ["plan", "sub", "projectId", "iat", "exp", "issuer", "features"];
+    for (const field of requiredFields) {
+      if (!(field in payload)) {
+        return {
+          isValid: false,
+          error: `Missing required field: ${field}`
+        };
+      }
+    }
+    if (typeof payload.plan !== "string" || !payload.plan.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid plan: must be a non-empty string"
+      };
+    }
+    if (typeof payload.sub !== "string" || !payload.sub.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid sub: must be a non-empty string"
+      };
+    }
+    if (typeof payload.projectId !== "string" || !payload.projectId.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid projectId: must be a non-empty string"
+      };
+    }
+    if (typeof payload.issuer !== "string" || !payload.issuer.trim()) {
+      return {
+        isValid: false,
+        error: "Invalid issuer: must be a non-empty string"
+      };
+    }
+    if (!Array.isArray(payload.features)) {
+      return {
+        isValid: false,
+        error: "Invalid features: must be an array"
+      };
+    }
+    if (typeof payload.iat !== "number" || payload.iat <= 0) {
+      return {
+        isValid: false,
+        error: "Invalid iat: must be a positive number"
+      };
+    }
+    if (typeof payload.exp !== "number" || payload.exp <= 0) {
+      return {
+        isValid: false,
+        error: "Invalid exp: must be a positive number"
+      };
+    }
+    if (payload.iat >= payload.exp) {
+      return {
+        isValid: false,
+        error: "Invalid timestamps: iat must be before exp"
+      };
+    }
+    return { isValid: true };
+  },
+  /**
+   * Check if license has expired
+   * @param payload - License payload
+   * @param currentTime - Current time to check against (defaults to now)
+   * @returns Validation result
+   */
+  checkExpiration(payload, currentTime = /* @__PURE__ */ new Date()) {
+    const now = Math.floor(currentTime.getTime() / 1e3);
+    const expiresAt = payload.exp;
+    if (now > expiresAt) {
+      return {
+        isValid: false,
+        error: `License expired on ${new Date(expiresAt * 1e3).toISOString()}`,
+        isExpired: true
+      };
+    }
+    return { isValid: true, isExpired: false };
+  },
+  /**
+   * Check if license has a specific feature
+   * @param payload - License payload
+   * @param feature - Feature to check
+   * @returns Whether the feature is available
+   */
+  hasFeature(payload, feature) {
+    return payload.features.includes("*") || payload.features.includes(feature);
+  },
+  /**
+   * Get license expiration status
+   * @param payload - License payload
+   * @param currentTime - Current time to check against (defaults to now)
+   * @returns Expiration information
+   */
+  getExpirationInfo(payload, currentTime = /* @__PURE__ */ new Date()) {
+    const now = Math.floor(currentTime.getTime() / 1e3);
+    const expiresAt = payload.exp;
+    const isExpired = now > expiresAt;
+    const daysUntilExpiration = Math.ceil((expiresAt - now) / (24 * 60 * 60));
+    return {
+      isExpired,
+      expiresAt: new Date(expiresAt * 1e3),
+      daysUntilExpiration: isExpired ? 0 : daysUntilExpiration
+    };
+  },
+  /**
+   * Decode JWT license without verification (for debugging)
+   * @param license - JWT license string
+   * @returns Decoded payload or null if invalid
+   */
+  decodeLicense(license) {
+    try {
+      const decoded = jwt2.decode(license);
+      return decoded;
+    } catch {
+      return null;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbortController,
   ArrayProto,
+  JWTLicenseSigner,
+  JWTLicenseValidator,
   XMLHttpRequest,
   absoluteUrl,
   assignableWindow,

package/dist/index.d.cts

@@ -11,8 +11,11 @@ export { isPublishedAtLeastOneEnvironment, isPublishedInAllEnvironments } from '
 export { deepClone } from './utils.cjs';
 export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.cjs';
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.cjs';
+export { GenerateLicenseOptions, JWTLicenseSigner, JWTLicenseSignerOptions } from './jwt-license-signer.cjs';
+export { JWTLicenseValidator } from './jwt-license-validator.cjs';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';
 import './storage.cjs';
 import '@usertour/types/';
 import 'clsx';
+import 'jsonwebtoken';

package/dist/index.d.ts

@@ -11,8 +11,11 @@ export { isPublishedAtLeastOneEnvironment, isPublishedInAllEnvironments } from '
 export { deepClone } from './utils.js';
 export { generateAutoStateColors, hexToHSLString, hexToRGBStr } from './color.js';
 export { absoluteUrl, cn, cuid, evalCode, formatDate, getRandomColor, hexToRgb, isDark, uuidV4 } from './helper.js';
+export { GenerateLicenseOptions, JWTLicenseSigner, JWTLicenseSignerOptions } from './jwt-license-signer.js';
+export { JWTLicenseValidator } from './jwt-license-validator.js';
 export { default as isEqual } from 'fast-deep-equal';
 import '@usertour/types';
 import './storage.js';
 import '@usertour/types/';
 import 'clsx';
+import 'jsonwebtoken';

package/dist/index.js

@@ -15,6 +15,12 @@ import {
 import {
   isUrl
 } from "./chunk-ZNFXGN3M.js";
+import {
+  JWTLicenseSigner
+} from "./chunk-JQ4E3IDB.js";
+import {
+  JWTLicenseValidator
+} from "./chunk-KJJ6UD5L.js";
 import {
   defaultStep
 } from "./chunk-FW54TSA3.js";
@@ -103,6 +109,8 @@ import "./chunk-XEO3YXBM.js";
 export {
   AbortController,
   ArrayProto,
+  JWTLicenseSigner,
+  JWTLicenseValidator,
   XMLHttpRequest,
   absoluteUrl,
   assignableWindow,

package/dist/jwt-license-signer.js

@@ -1,111 +1,7 @@
 import {
-  __publicField
-} from "./chunk-XEO3YXBM.js";
-
-// src/jwt-license-signer.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as jwt from "jsonwebtoken";
-var JWTLicenseSigner = class {
-  constructor(options) {
-    __publicField(this, "privateKey");
-    __publicField(this, "issuer");
-    __publicField(this, "algorithm");
-    this.privateKey = this.loadPrivateKey(options.privateKeyPath);
-    this.issuer = options.issuer || "https://www.usertour.io";
-    this.algorithm = options.algorithm || "RS256";
-  }
-  /**
-   * Load RSA private key from file
-   */
-  loadPrivateKey(keyPath) {
-    try {
-      const fullPath = path.resolve(keyPath);
-      return fs.readFileSync(fullPath, "utf8");
-    } catch (error) {
-      throw new Error(`Failed to load private key from ${keyPath}: ${error}`);
-    }
-  }
-  /**
-   * Generate a JWT license token
-   */
-  generateLicense(options) {
-    const now = Math.floor(Date.now() / 1e3);
-    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
-    const payload = {
-      plan: options.plan,
-      sub: options.subject,
-      projectId: options.projectId,
-      iat: now,
-      exp: expiresAt,
-      issuer: options.issuer || this.issuer,
-      features: options.features
-    };
-    try {
-      return jwt.sign(payload, this.privateKey, {
-        algorithm: this.algorithm,
-        issuer: this.issuer
-      });
-    } catch (error) {
-      throw new Error(`Failed to generate JWT license: ${error}`);
-    }
-  }
-  /**
-   * Generate a license and return both token and payload info
-   */
-  generateLicenseWithInfo(options) {
-    const now = Math.floor(Date.now() / 1e3);
-    const expiresAt = now + options.expiresInDays * 24 * 60 * 60;
-    const payload = {
-      plan: options.plan,
-      sub: options.subject,
-      projectId: options.projectId,
-      iat: now,
-      exp: expiresAt,
-      issuer: options.issuer || this.issuer,
-      features: options.features
-    };
-    const token = jwt.sign(payload, this.privateKey, {
-      algorithm: this.algorithm,
-      issuer: this.issuer
-    });
-    return {
-      token,
-      payload,
-      expiresAt: new Date(expiresAt * 1e3)
-    };
-  }
-  /**
-   * Decode a JWT token without verification (for debugging)
-   */
-  decodeToken(token) {
-    try {
-      return jwt.decode(token);
-    } catch (error) {
-      console.error("Failed to decode JWT token:", error);
-      return null;
-    }
-  }
-  /**
-   * Get token information without verification
-   */
-  getTokenInfo(token) {
-    try {
-      const decoded = jwt.decode(token, { complete: true });
-      if (!decoded || typeof decoded === "string") {
-        return null;
-      }
-      return {
-        header: decoded.header,
-        payload: decoded.payload,
-        signature: decoded.signature
-      };
-    } catch (error) {
-      console.error("Failed to get token info:", error);
-      return null;
-    }
-  }
-};
+  JWTLicenseSigner
+} from "./chunk-JQ4E3IDB.js";
+import "./chunk-XEO3YXBM.js";
 export {
   JWTLicenseSigner
 };

package/dist/jwt-license-validator.js

@@ -1,184 +1,7 @@
+import {
+  JWTLicenseValidator
+} from "./chunk-KJJ6UD5L.js";
 import "./chunk-XEO3YXBM.js";
-
-// src/jwt-license-validator.ts
-import * as jwt from "jsonwebtoken";
-var JWTLicenseValidator = {
-  /**
-   * Validate a JWT license
-   * @param license - JWT license string
-   * @param publicKey - RSA public key in PEM format
-   * @param options - Validation options
-   * @returns Validation result
-   */
-  validateLicense(license, publicKey, options = {}) {
-    try {
-      const { checkExpiration = true, currentTime = /* @__PURE__ */ new Date() } = options;
-      const decoded = jwt.verify(license, publicKey, {
-        algorithms: ["RS256"],
-        ignoreExpiration: !checkExpiration
-      });
-      const fieldValidation = this.validateRequiredFields(decoded);
-      if (!fieldValidation.isValid) {
-        return fieldValidation;
-      }
-      if (checkExpiration) {
-        const expirationValidation = this.checkExpiration(decoded, currentTime);
-        if (!expirationValidation.isValid) {
-          return expirationValidation;
-        }
-      }
-      const hasFeature = (feature) => {
-        return decoded.features.includes("*") || decoded.features.includes(feature);
-      };
-      return {
-        isValid: true,
-        payload: decoded,
-        isExpired: false,
-        hasFeature
-      };
-    } catch (error) {
-      if (error instanceof jwt.JsonWebTokenError) {
-        return {
-          isValid: false,
-          error: `JWT validation failed: ${error.message}`
-        };
-      }
-      if (error instanceof jwt.TokenExpiredError) {
-        return {
-          isValid: false,
-          error: `License expired: ${error.message}`,
-          isExpired: true
-        };
-      }
-      return {
-        isValid: false,
-        error: `License validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      };
-    }
-  },
-  /**
-   * Validate that all required fields are present in license payload
-   * @param payload - License payload to validate
-   * @returns Validation result
-   */
-  validateRequiredFields(payload) {
-    const requiredFields = ["plan", "sub", "projectId", "iat", "exp", "issuer", "features"];
-    for (const field of requiredFields) {
-      if (!(field in payload)) {
-        return {
-          isValid: false,
-          error: `Missing required field: ${field}`
-        };
-      }
-    }
-    if (typeof payload.plan !== "string" || !payload.plan.trim()) {
-      return {
-        isValid: false,
-        error: "Invalid plan: must be a non-empty string"
-      };
-    }
-    if (typeof payload.sub !== "string" || !payload.sub.trim()) {
-      return {
-        isValid: false,
-        error: "Invalid sub: must be a non-empty string"
-      };
-    }
-    if (typeof payload.projectId !== "string" || !payload.projectId.trim()) {
-      return {
-        isValid: false,
-        error: "Invalid projectId: must be a non-empty string"
-      };
-    }
-    if (typeof payload.issuer !== "string" || !payload.issuer.trim()) {
-      return {
-        isValid: false,
-        error: "Invalid issuer: must be a non-empty string"
-      };
-    }
-    if (!Array.isArray(payload.features)) {
-      return {
-        isValid: false,
-        error: "Invalid features: must be an array"
-      };
-    }
-    if (typeof payload.iat !== "number" || payload.iat <= 0) {
-      return {
-        isValid: false,
-        error: "Invalid iat: must be a positive number"
-      };
-    }
-    if (typeof payload.exp !== "number" || payload.exp <= 0) {
-      return {
-        isValid: false,
-        error: "Invalid exp: must be a positive number"
-      };
-    }
-    if (payload.iat >= payload.exp) {
-      return {
-        isValid: false,
-        error: "Invalid timestamps: iat must be before exp"
-      };
-    }
-    return { isValid: true };
-  },
-  /**
-   * Check if license has expired
-   * @param payload - License payload
-   * @param currentTime - Current time to check against (defaults to now)
-   * @returns Validation result
-   */
-  checkExpiration(payload, currentTime = /* @__PURE__ */ new Date()) {
-    const now = Math.floor(currentTime.getTime() / 1e3);
-    const expiresAt = payload.exp;
-    if (now > expiresAt) {
-      return {
-        isValid: false,
-        error: `License expired on ${new Date(expiresAt * 1e3).toISOString()}`,
-        isExpired: true
-      };
-    }
-    return { isValid: true, isExpired: false };
-  },
-  /**
-   * Check if license has a specific feature
-   * @param payload - License payload
-   * @param feature - Feature to check
-   * @returns Whether the feature is available
-   */
-  hasFeature(payload, feature) {
-    return payload.features.includes("*") || payload.features.includes(feature);
-  },
-  /**
-   * Get license expiration status
-   * @param payload - License payload
-   * @param currentTime - Current time to check against (defaults to now)
-   * @returns Expiration information
-   */
-  getExpirationInfo(payload, currentTime = /* @__PURE__ */ new Date()) {
-    const now = Math.floor(currentTime.getTime() / 1e3);
-    const expiresAt = payload.exp;
-    const isExpired = now > expiresAt;
-    const daysUntilExpiration = Math.ceil((expiresAt - now) / (24 * 60 * 60));
-    return {
-      isExpired,
-      expiresAt: new Date(expiresAt * 1e3),
-      daysUntilExpiration: isExpired ? 0 : daysUntilExpiration
-    };
-  },
-  /**
-   * Decode JWT license without verification (for debugging)
-   * @param license - JWT license string
-   * @returns Decoded payload or null if invalid
-   */
-  decodeLicense(license) {
-    try {
-      const decoded = jwt.decode(license);
-      return decoded;
-    } catch {
-      return null;
-    }
-  }
-};
 export {
   JWTLicenseValidator
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usertour/helpers",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",