@licenseseat/js 0.1.0 → 0.2.1

package/dist/types/LicenseSeat.d.ts

@@ -0,0 +1,309 @@
+/**
+ * Get or create the shared singleton instance
+ * @param {import('./types.js').LicenseSeatConfig} [config] - Configuration (only used on first call)
+ * @returns {LicenseSeatSDK} The shared instance
+ */
+export function getSharedInstance(config?: import("./types.js").LicenseSeatConfig): LicenseSeatSDK;
+/**
+ * Configure the shared singleton instance
+ * @param {import('./types.js').LicenseSeatConfig} config - Configuration options
+ * @param {boolean} [force=false] - Force reconfiguration even if already configured
+ * @returns {LicenseSeatSDK} The configured shared instance
+ */
+export function configure(config: import("./types.js").LicenseSeatConfig, force?: boolean): LicenseSeatSDK;
+/**
+ * Reset the shared singleton instance
+ * @returns {void}
+ */
+export function resetSharedInstance(): void;
+/**
+ * LicenseSeat SDK Main Class
+ *
+ * Provides license activation, validation, and entitlement checking
+ * for client-side JavaScript applications.
+ *
+ * @example
+ * ```js
+ * const sdk = new LicenseSeatSDK({
+ *   apiKey: 'your-api-key',
+ *   debug: true
+ * });
+ *
+ * // Activate a license
+ * await sdk.activate('LICENSE-KEY-HERE');
+ *
+ * // Check entitlements
+ * if (sdk.hasEntitlement('pro-features')) {
+ *   // Enable pro features
+ * }
+ * ```
+ */
+export class LicenseSeatSDK {
+    /**
+     * Create a new LicenseSeat SDK instance
+     * @param {import('./types.js').LicenseSeatConfig} [config={}] - Configuration options
+     */
+    constructor(config?: import("./types.js").LicenseSeatConfig);
+    /**
+     * SDK configuration
+     * @type {import('./types.js').LicenseSeatConfig}
+     */
+    config: import("./types.js").LicenseSeatConfig;
+    /**
+     * Event listeners map
+     * @type {Object<string, import('./types.js').EventCallback[]>}
+     * @private
+     */
+    private eventListeners;
+    /**
+     * Auto-validation timer ID
+     * @type {number|null}
+     * @private
+     */
+    private validationTimer;
+    /**
+     * License cache manager
+     * @type {LicenseCache}
+     * @private
+     */
+    private cache;
+    /**
+     * Current online status
+     * @type {boolean}
+     * @private
+     */
+    private online;
+    /**
+     * Current license key being auto-validated
+     * @type {string|null}
+     * @private
+     */
+    private currentAutoLicenseKey;
+    /**
+     * Connectivity polling timer ID
+     * @type {number|null}
+     * @private
+     */
+    private connectivityTimer;
+    /**
+     * Offline license refresh timer ID
+     * @type {number|null}
+     * @private
+     */
+    private offlineRefreshTimer;
+    /**
+     * Last offline validation result (to avoid duplicate emits)
+     * @type {import('./types.js').ValidationResult|null}
+     * @private
+     */
+    private lastOfflineValidation;
+    /**
+     * Flag to prevent concurrent syncOfflineAssets calls
+     * @type {boolean}
+     * @private
+     */
+    private syncingOfflineAssets;
+    /**
+     * Flag indicating if SDK has been destroyed
+     * @type {boolean}
+     * @private
+     */
+    private destroyed;
+    /**
+     * Initialize the SDK
+     * Loads cached license and starts auto-validation if configured.
+     * Called automatically unless autoInitialize is set to false.
+     * @returns {void}
+     */
+    initialize(): void;
+    /**
+     * Activate a license
+     * @param {string} licenseKey - The license key to activate
+     * @param {import('./types.js').ActivationOptions} [options={}] - Activation options
+     * @returns {Promise<import('./types.js').CachedLicense>} Activation result with cached license data
+     * @throws {APIError} When the API request fails
+     */
+    activate(licenseKey: string, options?: import("./types.js").ActivationOptions): Promise<import("./types.js").CachedLicense>;
+    /**
+     * Deactivate the current license
+     * @returns {Promise<Object>} Deactivation result from the API
+     * @throws {LicenseError} When no active license is found
+     * @throws {APIError} When the API request fails
+     */
+    deactivate(): Promise<any>;
+    /**
+     * Validate a license
+     * @param {string} licenseKey - License key to validate
+     * @param {import('./types.js').ValidationOptions} [options={}] - Validation options
+     * @returns {Promise<import('./types.js').ValidationResult>} Validation result
+     * @throws {APIError} When the API request fails and offline fallback is not available
+     */
+    validateLicense(licenseKey: string, options?: import("./types.js").ValidationOptions): Promise<import("./types.js").ValidationResult>;
+    /**
+     * Check if a specific entitlement is active (detailed version)
+     * @param {string} entitlementKey - The entitlement key to check
+     * @returns {import('./types.js').EntitlementCheckResult} Entitlement status with details
+     */
+    checkEntitlement(entitlementKey: string): import("./types.js").EntitlementCheckResult;
+    /**
+     * Check if a specific entitlement is active (simple boolean version)
+     * This is a convenience method that returns a simple boolean.
+     * Use checkEntitlement() for detailed status information.
+     * @param {string} entitlementKey - The entitlement key to check
+     * @returns {boolean} True if the entitlement is active, false otherwise
+     */
+    hasEntitlement(entitlementKey: string): boolean;
+    /**
+     * Get offline license data from the server
+     * @returns {Promise<import('./types.js').SignedOfflineLicense>} Signed offline license data
+     * @throws {LicenseError} When no active license is found
+     * @throws {APIError} When the API request fails
+     */
+    getOfflineLicense(): Promise<import("./types.js").SignedOfflineLicense>;
+    /**
+     * Fetch a public key from the server by key ID
+     * @param {string} keyId - The Key ID (kid) for which to fetch the public key
+     * @returns {Promise<string>} Base64-encoded public key
+     * @throws {Error} When keyId is not provided or the key is not found
+     */
+    getPublicKey(keyId: string): Promise<string>;
+    /**
+     * Verify a signed offline license client-side using Ed25519
+     * @param {import('./types.js').SignedOfflineLicense} signedLicenseData - The signed license data
+     * @param {string} publicKeyB64 - Base64-encoded public Ed25519 key
+     * @returns {Promise<boolean>} True if verification is successful
+     * @throws {CryptoError} When crypto library is not available
+     * @throws {Error} When inputs are invalid
+     */
+    verifyOfflineLicense(signedLicenseData: import("./types.js").SignedOfflineLicense, publicKeyB64: string): Promise<boolean>;
+    /**
+     * Get current license status
+     * @returns {import('./types.js').LicenseStatus} Current license status
+     */
+    getStatus(): import("./types.js").LicenseStatus;
+    /**
+     * Test server authentication
+     * Useful for verifying API key/session is valid.
+     * @returns {Promise<Object>} Result from the server
+     * @throws {Error} When API key is not configured
+     * @throws {APIError} When authentication fails
+     */
+    testAuth(): Promise<any>;
+    /**
+     * Clear all data and reset SDK state
+     * @returns {void}
+     */
+    reset(): void;
+    /**
+     * Destroy the SDK instance and release all resources
+     * Call this when you no longer need the SDK to prevent memory leaks.
+     * After calling destroy(), the SDK instance should not be used.
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Subscribe to an event
+     * @param {string} event - Event name
+     * @param {import('./types.js').EventCallback} callback - Event handler
+     * @returns {import('./types.js').EventUnsubscribe} Unsubscribe function
+     */
+    on(event: string, callback: import("./types.js").EventCallback): import("./types.js").EventUnsubscribe;
+    /**
+     * Unsubscribe from an event
+     * @param {string} event - Event name
+     * @param {import('./types.js').EventCallback} callback - Event handler to remove
+     * @returns {void}
+     */
+    off(event: string, callback: import("./types.js").EventCallback): void;
+    /**
+     * Emit an event
+     * @param {string} event - Event name
+     * @param {*} data - Event data
+     * @returns {void}
+     * @private
+     */
+    private emit;
+    /**
+     * Start automatic license validation
+     * @param {string} licenseKey - License key to validate
+     * @returns {void}
+     * @private
+     */
+    private startAutoValidation;
+    /**
+     * Stop automatic validation
+     * @returns {void}
+     * @private
+     */
+    private stopAutoValidation;
+    /**
+     * Start connectivity polling (when offline)
+     * @returns {void}
+     * @private
+     */
+    private startConnectivityPolling;
+    /**
+     * Stop connectivity polling
+     * @returns {void}
+     * @private
+     */
+    private stopConnectivityPolling;
+    /**
+     * Fetch and cache offline license and public key
+     * Uses a lock to prevent concurrent calls from causing race conditions
+     * @returns {Promise<void>}
+     * @private
+     */
+    private syncOfflineAssets;
+    /**
+     * Schedule periodic offline license refresh
+     * @returns {void}
+     * @private
+     */
+    private scheduleOfflineRefresh;
+    /**
+     * Verify cached offline license
+     * @returns {Promise<import('./types.js').ValidationResult>}
+     * @private
+     */
+    private verifyCachedOffline;
+    /**
+     * Quick offline verification using only local data (no network)
+     * Performs signature verification plus basic validity checks (expiry, license key match)
+     * @returns {Promise<import('./types.js').ValidationResult|null>}
+     * @private
+     */
+    private quickVerifyCachedOfflineLocal;
+    /**
+     * Make an API call with retry logic
+     * @param {string} endpoint - API endpoint (will be appended to apiBaseUrl)
+     * @param {Object} [options={}] - Fetch options
+     * @param {string} [options.method="GET"] - HTTP method
+     * @param {Object} [options.body] - Request body (will be JSON-stringified)
+     * @param {Object} [options.headers] - Additional headers
+     * @returns {Promise<Object>} API response data
+     * @throws {APIError} When the request fails after all retries
+     * @private
+     */
+    private apiCall;
+    /**
+     * Determine if an error should be retried
+     * @param {Error} error - The error to check
+     * @returns {boolean} True if the error should trigger a retry
+     * @private
+     */
+    private shouldRetryError;
+    /**
+     * Get CSRF token from meta tag
+     * @returns {string} CSRF token or empty string
+     */
+    getCsrfToken(): string;
+    /**
+     * Log a message (if debug mode is enabled)
+     * @param {...*} args - Arguments to log
+     * @returns {void}
+     * @private
+     */
+    private log;
+}
+//# sourceMappingURL=LicenseSeat.d.ts.map

package/dist/types/LicenseSeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LicenseSeat.d.ts","sourceRoot":"","sources":["../../src/LicenseSeat.js"],"names":[],"mappings":"AAwrCA;;;;GAIG;AACH,2CAHW,OAAO,YAAY,EAAE,iBAAiB,GACpC,cAAc,CAO1B;AAED;;;;;GAKG;AACH,kCAJW,OAAO,YAAY,EAAE,iBAAiB,UACtC,OAAO,GACL,cAAc,CAW1B;AAED;;;GAGG;AACH,uCAFa,IAAI,CAOhB;AAxqCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACE;;;OAGG;IACH,qBAFW,OAAO,YAAY,EAAE,iBAAiB,EA+FhD;IA5FC;;;OAGG;IACH,QAFU,OAAO,YAAY,EAAE,iBAAiB,CAK/C;IAED;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,wBAA2B;IAE3B;;;;OAIG;IACH,cAAwD;IAExD;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,8BAAiC;IAEjC;;;;OAIG;IACH,0BAA6B;IAE7B;;;;OAIG;IACH,4BAA+B;IAE/B;;;;OAIG;IACH,8BAAiC;IAEjC;;;;OAIG;IACH,6BAAiC;IAEjC;;;;OAIG;IACH,kBAAsB;IAiBxB;;;;;OAKG;IACH,cAFa,IAAI,CAkDhB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,YACN,OAAO,YAAY,EAAE,iBAAiB,GACpC,OAAO,CAAC,OAAO,YAAY,EAAE,aAAa,CAAC,CA4CvD;IAED;;;;;OAKG;IACH,cAJa,OAAO,KAAQ,CA+B3B;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,OAAO,YAAY,EAAE,iBAAiB,GACpC,OAAO,CAAC,OAAO,YAAY,EAAE,gBAAgB,CAAC,CAyF1D;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,YAAY,EAAE,sBAAsB,CA6BvD;IAED;;;;;;OAMG;IACH,+BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,qBAJa,OAAO,CAAC,OAAO,YAAY,EAAE,oBAAoB,CAAC,CAmC9D;IAED;;;;;OAKG;IACH,oBAJW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAwB3B;IAED;;;;;;;OAOG;IACH,wCANW,OAAO,YAAY,EAAE,oBAAoB,gBACzC,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAuD5B;IAED;;;OAGG;IACH,aAFa,OAAO,YAAY,EAAE,aAAa,CA6C9C;IAED;;;;;;OAMG;IACH,YAJa,OAAO,KAAQ,CAoB3B;IAED;;;OAGG;IACH,SAFa,IAAI,CAahB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAehB;IAMD;;;;;OAKG;IACH,UAJW,MAAM,YACN,OAAO,YAAY,EAAE,aAAa,GAChC,OAAO,YAAY,EAAE,gBAAgB,CAQjD;IAED;;;;;OAKG;IACH,WAJW,MAAM,YACN,OAAO,YAAY,EAAE,aAAa,GAChC,IAAI,CAQhB;IAED;;;;;;OAMG;IACH,aAWC;IAMD;;;;;OAKG;IACH,4BAqBC;IAED;;;;OAIG;IACH,2BAMC;IAED;;;;OAIG;IACH,iCA4BC;IAED;;;;OAIG;IACH,gCAKC;IAMD;;;;;OAKG;IACH,0BAwCC;IAED;;;;OAIG;IACH,+BAMC;IAED;;;;OAIG;IACH,4BA0EC;IAED;;;;;OAKG;IACH,sCA+CC;IAMD;;;;;;;;;;OAUG;IACH,gBAiFC;IAED;;;;;OAKG;IACH,yBAsBC;IAMD;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,YAIC;CACF"}

package/dist/types/cache.d.ts

@@ -0,0 +1,93 @@
+/**
+ * LicenseSeat SDK Cache Manager
+ * Handles persistent storage of license data, offline licenses, and public keys.
+ * @module cache
+ */
+/**
+ * License Cache Manager
+ * Manages persistent storage of license data using localStorage.
+ */
+export class LicenseCache {
+    /**
+     * Create a LicenseCache instance
+     * @param {string} [prefix="licenseseat_"] - Prefix for all localStorage keys
+     */
+    constructor(prefix?: string);
+    /** @type {string} */
+    prefix: string;
+    /** @type {string} */
+    publicKeyCacheKey: string;
+    /**
+     * Get the cached license data
+     * @returns {import('./types.js').CachedLicense|null} Cached license or null if not found
+     */
+    getLicense(): import("./types.js").CachedLicense | null;
+    /**
+     * Store license data in cache
+     * @param {import('./types.js').CachedLicense} data - License data to cache
+     * @returns {void}
+     */
+    setLicense(data: import("./types.js").CachedLicense): void;
+    /**
+     * Update the validation data for the cached license
+     * @param {import('./types.js').ValidationResult} validationData - Validation result to store
+     * @returns {void}
+     */
+    updateValidation(validationData: import("./types.js").ValidationResult): void;
+    /**
+     * Get the device identifier from the cached license
+     * @returns {string|null} Device identifier or null if not found
+     */
+    getDeviceId(): string | null;
+    /**
+     * Clear the cached license data
+     * @returns {void}
+     */
+    clearLicense(): void;
+    /**
+     * Get the cached offline license
+     * @returns {import('./types.js').SignedOfflineLicense|null} Offline license or null if not found
+     */
+    getOfflineLicense(): import("./types.js").SignedOfflineLicense | null;
+    /**
+     * Store offline license data in cache
+     * @param {import('./types.js').SignedOfflineLicense} data - Signed offline license to cache
+     * @returns {void}
+     */
+    setOfflineLicense(data: import("./types.js").SignedOfflineLicense): void;
+    /**
+     * Clear the cached offline license
+     * @returns {void}
+     */
+    clearOfflineLicense(): void;
+    /**
+     * Get a cached public key by key ID
+     * @param {string} keyId - The key ID to look up
+     * @returns {string|null} Base64-encoded public key or null if not found
+     */
+    getPublicKey(keyId: string): string | null;
+    /**
+     * Store a public key in cache
+     * @param {string} keyId - The key ID
+     * @param {string} publicKeyB64 - Base64-encoded public key
+     * @returns {void}
+     */
+    setPublicKey(keyId: string, publicKeyB64: string): void;
+    /**
+     * Clear all LicenseSeat SDK data for this prefix
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Get the last seen timestamp (for clock tamper detection)
+     * @returns {number|null} Unix timestamp in milliseconds or null if not set
+     */
+    getLastSeenTimestamp(): number | null;
+    /**
+     * Store the last seen timestamp
+     * @param {number} ts - Unix timestamp in milliseconds
+     * @returns {void}
+     */
+    setLastSeenTimestamp(ts: number): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/types/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH;IACE;;;OAGG;IACH,qBAFW,MAAM,EAOhB;IAJC,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,qBAAqB;IACrB,mBADW,MAAM,CACmC;IAGtD;;;OAGG;IACH,cAFa,OAAO,YAAY,EAAE,aAAa,GAAC,IAAI,CAUnD;IAED;;;;OAIG;IACH,iBAHW,OAAO,YAAY,EAAE,aAAa,GAChC,IAAI,CAQhB;IAED;;;;OAIG;IACH,iCAHW,OAAO,YAAY,EAAE,gBAAgB,GACnC,IAAI,CAShB;IAED;;;OAGG;IACH,eAFa,MAAM,GAAC,IAAI,CAKvB;IAED;;;OAGG;IACH,gBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAFa,OAAO,YAAY,EAAE,oBAAoB,GAAC,IAAI,CAU1D;IAED;;;;OAIG;IACH,wBAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,IAAI,CAWhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAYvB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,gBACN,MAAM,GACJ,IAAI,CAYhB;IAED;;;OAGG;IACH,SAFa,IAAI,CAUhB;IAED;;;OAGG;IACH,wBAFa,MAAM,GAAC,IAAI,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,IAAI,CAQhB;CACF"}

package/dist/types/errors.d.ts

@@ -0,0 +1,58 @@
+/**
+ * LicenseSeat SDK Error Classes
+ * @module errors
+ */
+/**
+ * Custom API Error class for HTTP request failures
+ * @extends Error
+ */
+export class APIError extends Error {
+    /**
+     * Create an APIError
+     * @param {string} message - Error message
+     * @param {number} status - HTTP status code (0 for network failures)
+     * @param {import('./types.js').APIErrorData} [data] - Additional error data from the API response
+     */
+    constructor(message: string, status: number, data?: import("./types.js").APIErrorData);
+    /** @type {number} */
+    status: number;
+    /** @type {import('./types.js').APIErrorData|undefined} */
+    data: import("./types.js").APIErrorData | undefined;
+}
+/**
+ * Error thrown when SDK operations are attempted without proper configuration
+ * @extends Error
+ */
+export class ConfigurationError extends Error {
+    /**
+     * Create a ConfigurationError
+     * @param {string} message - Error message
+     */
+    constructor(message: string);
+}
+/**
+ * Error thrown when license operations fail
+ * @extends Error
+ */
+export class LicenseError extends Error {
+    /**
+     * Create a LicenseError
+     * @param {string} message - Error message
+     * @param {string} [code] - Machine-readable error code
+     */
+    constructor(message: string, code?: string);
+    /** @type {string|undefined} */
+    code: string | undefined;
+}
+/**
+ * Error thrown when cryptographic operations fail
+ * @extends Error
+ */
+export class CryptoError extends Error {
+    /**
+     * Create a CryptoError
+     * @param {string} message - Error message
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH;IACE;;;;;OAKG;IACH,qBAJW,MAAM,UACN,MAAM,SACN,OAAO,YAAY,EAAE,YAAY,EAU3C;IAJC,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,0DAA0D;IAC1D,MADW,OAAO,YAAY,EAAE,YAAY,GAAC,SAAS,CACtC;CAEnB;AAED;;;GAGG;AACH;IACE;;;OAGG;IACH,qBAFW,MAAM,EAMhB;CACF;AAED;;;GAGG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,SACN,MAAM,EAQhB;IAFC,+BAA+B;IAC/B,MADW,MAAM,GAAC,SAAS,CACX;CAEnB;AAED;;;GAGG;AACH;IACE;;;OAGG;IACH,qBAFW,MAAM,EAMhB;CACF"}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { LicenseCache } from "./cache.js";
+export default LicenseSeatSDK;
+import { LicenseSeatSDK } from "./LicenseSeat.js";
+export { LicenseSeatSDK, getSharedInstance, configure, resetSharedInstance } from "./LicenseSeat.js";
+export { APIError, ConfigurationError, LicenseError, CryptoError } from "./errors.js";
+export { parseActiveEntitlements, constantTimeEqual, canonicalJsonStringify, base64UrlDecode, generateDeviceId, getCsrfToken } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;+BA4D+B,kBAAkB"}