@usertour/helpers 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  deepClone
+} from "./chunk-2AEGAICC.js";
 import {
   absoluteUrl,
   cn,
@@ -15,9 +18,6 @@ import {
 import {
   defaultStep
 } from "./chunk-FW54TSA3.js";
-import {
-  deepClone
-} from "./chunk-2AEGAICC.js";
 import {
   getAuthToken,
   removeAuthToken,

package/dist/jwt-license-signer.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/jwt-license-signer.ts
+var jwt_license_signer_exports = {};
+__export(jwt_license_signer_exports, {
+  JWTLicenseSigner: () => JWTLicenseSigner
+});
+module.exports = __toCommonJS(jwt_license_signer_exports);
+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;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JWTLicenseSigner
+});

package/dist/jwt-license-signer.d.cts

@@ -0,0 +1,61 @@
+import * as jwt from 'jsonwebtoken';
+import { JWTLicensePayload } from '@usertour/types';
+
+interface JWTLicenseSignerOptions {
+    /** RSA private key path */
+    privateKeyPath: string;
+    /** JWT issuer */
+    issuer?: string;
+    /** JWT algorithm */
+    algorithm?: jwt.Algorithm;
+}
+interface GenerateLicenseOptions {
+    /** License plan type */
+    plan: string;
+    /** Subject (project name) */
+    subject: string;
+    /** Project identifier */
+    projectId: string;
+    /** Expiration days from now */
+    expiresInDays: number;
+    /** Array of enabled features, '*' means all features */
+    features: string[];
+    /** Custom issuer (optional) */
+    issuer?: string;
+}
+declare class JWTLicenseSigner {
+    private privateKey;
+    private issuer;
+    private algorithm;
+    constructor(options: JWTLicenseSignerOptions);
+    /**
+     * Load RSA private key from file
+     */
+    private loadPrivateKey;
+    /**
+     * Generate a JWT license token
+     */
+    generateLicense(options: GenerateLicenseOptions): string;
+    /**
+     * Generate a license and return both token and payload info
+     */
+    generateLicenseWithInfo(options: GenerateLicenseOptions): {
+        token: string;
+        payload: JWTLicensePayload;
+        expiresAt: Date;
+    };
+    /**
+     * Decode a JWT token without verification (for debugging)
+     */
+    decodeToken(token: string): JWTLicensePayload | null;
+    /**
+     * Get token information without verification
+     */
+    getTokenInfo(token: string): {
+        header: jwt.JwtHeader;
+        payload: JWTLicensePayload;
+        signature: string;
+    } | null;
+}
+
+export { type GenerateLicenseOptions, JWTLicenseSigner, type JWTLicenseSignerOptions };

package/dist/jwt-license-signer.d.ts

@@ -0,0 +1,61 @@
+import * as jwt from 'jsonwebtoken';
+import { JWTLicensePayload } from '@usertour/types';
+
+interface JWTLicenseSignerOptions {
+    /** RSA private key path */
+    privateKeyPath: string;
+    /** JWT issuer */
+    issuer?: string;
+    /** JWT algorithm */
+    algorithm?: jwt.Algorithm;
+}
+interface GenerateLicenseOptions {
+    /** License plan type */
+    plan: string;
+    /** Subject (project name) */
+    subject: string;
+    /** Project identifier */
+    projectId: string;
+    /** Expiration days from now */
+    expiresInDays: number;
+    /** Array of enabled features, '*' means all features */
+    features: string[];
+    /** Custom issuer (optional) */
+    issuer?: string;
+}
+declare class JWTLicenseSigner {
+    private privateKey;
+    private issuer;
+    private algorithm;
+    constructor(options: JWTLicenseSignerOptions);
+    /**
+     * Load RSA private key from file
+     */
+    private loadPrivateKey;
+    /**
+     * Generate a JWT license token
+     */
+    generateLicense(options: GenerateLicenseOptions): string;
+    /**
+     * Generate a license and return both token and payload info
+     */
+    generateLicenseWithInfo(options: GenerateLicenseOptions): {
+        token: string;
+        payload: JWTLicensePayload;
+        expiresAt: Date;
+    };
+    /**
+     * Decode a JWT token without verification (for debugging)
+     */
+    decodeToken(token: string): JWTLicensePayload | null;
+    /**
+     * Get token information without verification
+     */
+    getTokenInfo(token: string): {
+        header: jwt.JwtHeader;
+        payload: JWTLicensePayload;
+        signature: string;
+    } | null;
+}
+
+export { type GenerateLicenseOptions, JWTLicenseSigner, type JWTLicenseSignerOptions };

package/dist/jwt-license-signer.js

@@ -0,0 +1,111 @@
+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/jwt-license-validator.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/jwt-license-validator.ts
+var jwt_license_validator_exports = {};
+__export(jwt_license_validator_exports, {
+  JWTLicenseValidator: () => JWTLicenseValidator
+});
+module.exports = __toCommonJS(jwt_license_validator_exports);
+var jwt = __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 = 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;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JWTLicenseValidator
+});

package/dist/jwt-license-validator.d.cts

@@ -0,0 +1,54 @@
+import { JWTLicenseValidationOptions, JWTLicenseValidationResult, JWTLicensePayload } from '@usertour/types';
+
+/**
+ * JWT License validator
+ */
+declare const 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: string, publicKey: string, options?: JWTLicenseValidationOptions): JWTLicenseValidationResult;
+    /**
+     * Validate that all required fields are present in license payload
+     * @param payload - License payload to validate
+     * @returns Validation result
+     */
+    validateRequiredFields(payload: JWTLicensePayload): JWTLicenseValidationResult;
+    /**
+     * Check if license has expired
+     * @param payload - License payload
+     * @param currentTime - Current time to check against (defaults to now)
+     * @returns Validation result
+     */
+    checkExpiration(payload: JWTLicensePayload, currentTime?: Date): JWTLicenseValidationResult;
+    /**
+     * Check if license has a specific feature
+     * @param payload - License payload
+     * @param feature - Feature to check
+     * @returns Whether the feature is available
+     */
+    hasFeature(payload: JWTLicensePayload, feature: string): boolean;
+    /**
+     * Get license expiration status
+     * @param payload - License payload
+     * @param currentTime - Current time to check against (defaults to now)
+     * @returns Expiration information
+     */
+    getExpirationInfo(payload: JWTLicensePayload, currentTime?: Date): {
+        isExpired: boolean;
+        expiresAt: Date;
+        daysUntilExpiration: number;
+    };
+    /**
+     * Decode JWT license without verification (for debugging)
+     * @param license - JWT license string
+     * @returns Decoded payload or null if invalid
+     */
+    decodeLicense(license: string): JWTLicensePayload | null;
+};
+
+export { JWTLicenseValidator };

package/dist/jwt-license-validator.d.ts

@@ -0,0 +1,54 @@
+import { JWTLicenseValidationOptions, JWTLicenseValidationResult, JWTLicensePayload } from '@usertour/types';
+
+/**
+ * JWT License validator
+ */
+declare const 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: string, publicKey: string, options?: JWTLicenseValidationOptions): JWTLicenseValidationResult;
+    /**
+     * Validate that all required fields are present in license payload
+     * @param payload - License payload to validate
+     * @returns Validation result
+     */
+    validateRequiredFields(payload: JWTLicensePayload): JWTLicenseValidationResult;
+    /**
+     * Check if license has expired
+     * @param payload - License payload
+     * @param currentTime - Current time to check against (defaults to now)
+     * @returns Validation result
+     */
+    checkExpiration(payload: JWTLicensePayload, currentTime?: Date): JWTLicenseValidationResult;
+    /**
+     * Check if license has a specific feature
+     * @param payload - License payload
+     * @param feature - Feature to check
+     * @returns Whether the feature is available
+     */
+    hasFeature(payload: JWTLicensePayload, feature: string): boolean;
+    /**
+     * Get license expiration status
+     * @param payload - License payload
+     * @param currentTime - Current time to check against (defaults to now)
+     * @returns Expiration information
+     */
+    getExpirationInfo(payload: JWTLicensePayload, currentTime?: Date): {
+        isExpired: boolean;
+        expiresAt: Date;
+        daysUntilExpiration: number;
+    };
+    /**
+     * Decode JWT license without verification (for debugging)
+     * @param license - JWT license string
+     * @returns Decoded payload or null if invalid
+     */
+    decodeLicense(license: string): JWTLicensePayload | null;
+};
+
+export { JWTLicenseValidator };

package/dist/jwt-license-validator.js

@@ -0,0 +1,184 @@
+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.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Utility functions and helpers shared across the UserTour project",
   "homepage": "https://www.usertour.io",
@@ -26,7 +26,7 @@
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
-    "@usertour/types": "^0.0.1",
+    "@usertour/types": "^0.0.4",
     "fast-deep-equal": "^3.1.3",
     "chroma-js": "^3.1.2",
     "deepmerge-ts": "^7.1.3",
@@ -34,19 +34,17 @@
     "class-variance-authority": "^0.4.0",
     "clsx": "^1.2.1",
     "tailwind-merge": "^1.13.2",
+    "jsonwebtoken": "^9.0.2",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^5.59.0",
     "@typescript-eslint/parser": "^5.59.0",
-    "@vitejs/plugin-react": "^4.0.0",
     "@types/chroma-js": "^3.1.1",
     "@types/uuid": "^9.0.6",
     "eslint": "^8.38.0",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.3.4",
-    "typescript": "^5.0.2",
-    "vite": "^4.3.9"
+    "@types/jsonwebtoken": "^9.0.10",
+    "typescript": "^5.0.2"
   },
   "tsup": {
     "clean": true,

package/dist/vite-env.d.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/vite-env.d.d.cts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

package/dist/vite-env.d.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />