@designbasekorea/figma-license-core 0.3.2 → 0.4.0

package/dist/index.umd.js

@@ -58,6 +58,7 @@
     function inferCode(text) {
         const normalized = text.toLowerCase();
         if (normalized.includes('activation limit')
+            || normalized.includes('activation_limit_reached')
             || normalized.includes('seat')
             || normalized.includes('too many activations')
             || normalized.includes('already activated on maximum')) {
@@ -168,7 +169,7 @@
                 return '이 멤버십 라이선스는 철회되었습니다.';
             case 'expired':
             case 'license_expired':
-                return '멤버십 라이선스가 만료되었습니다. YouTube 커뮤니티에서 이번 달 키를 확인해 주세요.';
+                return '라이선스가 만료되었습니다. 새 키를 확인해 주세요.';
             case 'not_started':
                 return '이 멤버십 라이선스는 아직 시작되지 않았습니다.';
             case 'rate_limited':
@@ -185,6 +186,8 @@
     function validationErrorCode(result) {
         const status = (result.errorCode || result.licenseStatus || '').toLowerCase();
         switch (status) {
+            case 'activation_limit_reached':
+                return exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED;
             case 'expired':
             case 'license_expired':
                 return exports.LicenseErrorCode.LICENSE_EXPIRED;
@@ -295,7 +298,7 @@
         }
         async initialize() {
             let state = await this.getStatus();
-            if (state.paymentStatus === 'PAID' && state.licenseKey && state.licenseKey !== this.config.masterCode) {
+            if (state.licenseKey && state.licenseKey !== this.config.masterCode) {
                 try {
                     const validateResult = this.deps.transport.validate
                         ? await this.deps.transport.validate({
@@ -436,10 +439,12 @@
             }
             let verifyResult;
             try {
+                const current = await this.getStatus();
                 verifyResult = await this.deps.transport.verify({
                     licenseKey: trimmedLicenseKey,
                     productId: this.config.productId,
                     instanceName: this.config.instanceName,
+                    instanceId: current.licenseKey === trimmedLicenseKey ? current.instanceId : undefined,
                 });
             }
             catch (error) {
@@ -455,7 +460,9 @@
             }
             const activationLimit = toNonNegativeNumber(verifyResult.activationLimit, 0);
             const activationUsage = toNonNegativeNumber(verifyResult.activationUsage, 0);
-            if (isActivationLimitReached(activationLimit, activationUsage)) {
+            // A verified instance already occupies its seat. usage === limit is not
+            // an error after successful activation (e.g. the first device on a 1-seat key).
+            if (!verifyResult.instanceId && isActivationLimitReached(activationLimit, activationUsage)) {
                 throw new LicenseCoreError(exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED, '활성화 가능한 기기 수를 모두 사용했습니다. 기존 기기를 비활성화한 뒤 다시 시도해 주세요.', verifyResult);
             }
             const current = await this.getStatus();
@@ -795,12 +802,14 @@
     }
     function failureMessageForStatus(status) {
         switch (status) {
+            case 'activation_limit_reached':
+                return '이 라이선스의 활성화 기기 수를 초과했습니다. 기존 기기에서 먼저 비활성화해 주세요.';
             case 'not_started':
                 return '이번 달 라이선스의 사용 기간이 아직 시작되지 않았습니다.';
             case 'expired':
-                return '라이선스가 만료되었습니다. 이번 달 키를 다시 확인해 주세요.';
+                return '라이선스가 만료되었습니다. 새 키를 확인해 주세요.';
             case 'revoked':
-                return '사용 중지된 라이선스입니다. 새 키를 확인해 주세요.';
+                return '사용 중지된 라이선스입니다. 구매 내역이나 관리자에게 문의해 주세요.';
             case 'product_not_allowed':
                 return '이 라이선스는 현재 플러그인에서 사용할 수 없습니다.';
             case 'rate_limited':
@@ -816,9 +825,12 @@
         const statusValid = typeof licenseStatus === 'string'
             ? licenseStatus.toLowerCase() === 'active'
             : undefined;
-        const valid = readBooleanField(body, ['valid', 'success', 'active'])
+        const rejectedStatus = ['expired', 'revoked', 'invalid', 'inactive', 'not_started',
+            'product_not_allowed', 'rate_limited', 'activation_limit_reached', 'environment_mismatch', 'mode_unverified']
+            .includes(licenseStatus?.trim().toLowerCase() || '');
+        const valid = !rejectedStatus && (readBooleanField(body, ['valid', 'success', 'active'])
             ?? statusValid
-            ?? false;
+            ?? false);
         const normalizedStatus = licenseStatus?.trim().toLowerCase();
         const fallbackMessage = !valid ? failureMessageForStatus(normalizedStatus) : undefined;
         const message = readTextField(body, ['message', 'error', 'detail']) || fallbackMessage;
@@ -1193,6 +1205,205 @@
         }
     }
 
+    /** Copy legacy storage once. Paid status is revalidated before any UI is published. */
+    async function migrateLegacyLicenseStorage(storage, prefix, keys = {}) {
+        const oldKey = (field) => {
+            const oldPrefix = keys.sourcePrefix ? `${keys.sourcePrefix}:` : '';
+            return `${oldPrefix}${keys[field] || field}`;
+        };
+        const marker = `${prefix}:legacyMigration`;
+        if (await storage.get(marker))
+            return;
+        const existing = await storage.get(`${prefix}:paymentStatus`);
+        if (existing === undefined || existing === null) {
+            const key = await storage.get(oldKey('licenseKey'));
+            const instanceId = await storage.get(oldKey('instanceId'));
+            const paymentStatus = await storage.get(oldKey('paymentStatus'));
+            const usage = await storage.get(oldKey('usageCount'));
+            if (typeof key === 'string' && key.trim()) {
+                await storage.set(`${prefix}:licenseKey`, key.trim());
+                await storage.set(`${prefix}:instanceId`, typeof instanceId === 'string' ? instanceId : '');
+                await storage.set(`${prefix}:planTier`, paymentStatus === 'PAID' ? 'PAID' : 'FREE');
+            }
+            if (typeof usage === 'number' && Number.isFinite(usage) && usage >= 0) {
+                await storage.set(`${prefix}:usageCount`, Math.floor(usage));
+            }
+            if (typeof key === 'string' && key.trim()) {
+                await storage.set(`${prefix}:paymentStatus`, paymentStatus === 'PAID' ? 'PAID' : 'FREE');
+            }
+        }
+        // Do not delete legacy keys: another version may still need them for rollback.
+        await storage.set(marker, 1);
+    }
+    async function readOrCreateDeviceId(storage, prefix) {
+        const storageKey = `${prefix}:deviceId`;
+        const current = await storage.get(storageKey);
+        if (typeof current === 'string' && current.length > 0)
+            return current;
+        const legacy = await storage.get('licenseDeviceId');
+        const nonce = `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+        const device = typeof legacy === 'string' && legacy.length > 0
+            ? legacy
+            : `license-${Date.now().toString(36)}-${nonce}`;
+        await storage.set(storageKey, device);
+        return device;
+    }
+    const pendingDeviceIds = new WeakMap();
+    async function getPersistentLicenseDeviceId(storage, prefix) {
+        let pending = pendingDeviceIds.get(storage);
+        if (!pending) {
+            pending = new Map();
+            pendingDeviceIds.set(storage, pending);
+        }
+        const existing = pending.get(prefix);
+        if (existing)
+            return existing;
+        const request = readOrCreateDeviceId(storage, prefix);
+        pending.set(prefix, request);
+        try {
+            return await request;
+        }
+        finally {
+            pending.delete(prefix);
+        }
+    }
+
+    const errors = {
+        expired: [
+            exports.LicenseErrorCode.LICENSE_EXPIRED,
+            '라이선스가 만료되었습니다. 구매 내역 또는 이번 달 멤버십 키를 확인해 주세요.',
+        ],
+        revoked: [exports.LicenseErrorCode.LICENSE_REVOKED, '사용 중지된 라이선스입니다.'],
+        not_started: [
+            exports.LicenseErrorCode.INVALID_LICENSE,
+            '라이선스 사용 기간이 아직 시작되지 않았습니다.',
+        ],
+        product_not_allowed: [
+            exports.LicenseErrorCode.PRODUCT_MISMATCH,
+            '이 라이선스는 현재 플러그인 구매 키가 아닙니다.',
+        ],
+        environment_mismatch: [
+            exports.LicenseErrorCode.INVALID_LICENSE,
+            '테스트 구매 키는 테스트 인증 서버에서만 사용할 수 있습니다.',
+        ],
+        mode_unverified: [
+            exports.LicenseErrorCode.NETWORK_ERROR,
+            '라이선스의 테스트·운영 구분을 확인하지 못했습니다.',
+        ],
+        rate_limited: [
+            exports.LicenseErrorCode.RATE_LIMITED,
+            '인증 요청이 너무 많습니다. 잠시 후 다시 시도해 주세요.',
+        ],
+        network_error: [
+            exports.LicenseErrorCode.NETWORK_ERROR,
+            '라이선스 서버에 연결하지 못했습니다. 다시 시도해 주세요.',
+        ],
+        activation_limit_reached: [
+            exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED,
+            '사용 가능한 기기 수를 모두 사용했습니다. 다른 기기에서 해제해 주세요.',
+        ],
+        activation_required: [exports.LicenseErrorCode.INVALID_LICENSE, '라이선스를 다시 인증해 주세요.'],
+        invalid_instance: [
+            exports.LicenseErrorCode.INVALID_LICENSE,
+            '이 기기의 인증 정보가 만료되었습니다. 다시 인증해 주세요.',
+        ],
+    };
+    function normalizeWordPressLicenseResponse(raw, productId) {
+        const data = raw && typeof raw === 'object' ? raw : {};
+        const status = typeof data.status === 'string' ? data.status : 'invalid';
+        if (data.valid !== true || status !== 'active') {
+            const [code, message] = errors[status] || [
+                exports.LicenseErrorCode.INVALID_LICENSE,
+                '유효하지 않은 라이선스 키입니다.',
+            ];
+            throw new LicenseCoreError(code, message, undefined, code === exports.LicenseErrorCode.NETWORK_ERROR || code === exports.LicenseErrorCode.RATE_LIMITED);
+        }
+        if (data.product_id !== productId) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.PRODUCT_MISMATCH, '인증 서버의 상품 정보가 일치하지 않습니다.');
+        }
+        const source = typeof data.source === 'string' ? data.source : '';
+        if (data.provider === 'lemon_api' &&
+            (typeof data.instance_id !== 'string' || !data.instance_id)) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.INVALID_LICENSE, '기기 활성화 정보를 확인하지 못했습니다.');
+        }
+        return {
+            valid: true,
+            productId,
+            planTier: 'PAID',
+            licenseStatus: 'active',
+            instanceId: typeof data.instance_id === 'string' ? data.instance_id : undefined,
+            activationLimit: typeof data.activation_limit === 'number' ? data.activation_limit : 0,
+            activationUsage: typeof data.activation_usage === 'number' ? data.activation_usage : 0,
+            licenseSource: source,
+            accessScope: typeof data.access_scope === 'string' ? data.access_scope : 'product',
+            expiresAt: typeof data.expires_at === 'string' ? data.expires_at : undefined,
+        };
+    }
+    function createWordPressLicenseTransport(options) {
+        const { storage, storagePrefix: prefix, productId } = options;
+        if (!productId.trim() || !prefix.trim())
+            throw new Error('productId and storagePrefix are required.');
+        if (!/^https:\/\//i.test(options.baseUrl) &&
+            !/^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?(\/|$)/i.test(options.baseUrl)) {
+            throw new Error('License server must use HTTPS (HTTP is allowed only for local development).');
+        }
+        const timeout = options.timeoutMs || 20000;
+        const fetchFn = options.fetchFn || fetch;
+        const body = (payload) => ({
+            license_key: payload.licenseKey,
+            product_id: productId,
+            instance_id: payload.instanceId || '',
+            device_id: payload.deviceId,
+        });
+        const base = options.baseUrl.replace(/\/$/, '');
+        const http = new FetchLicenseTransport({
+            verifyUrl: `${base}/activate`,
+            validateUrl: `${base}/validate`,
+            deactivateUrl: `${base}/deactivate`,
+            fetchFn,
+            useAbortSignal: false,
+            timeoutMs: timeout,
+            buildVerifyBody: body,
+            buildValidateBody: body,
+            buildDeactivateBody: body,
+            normalizeVerifyResponse: (raw) => normalizeWordPressLicenseResponse(raw, productId),
+            normalizeDeactivateResponse: (raw) => {
+                const data = raw && typeof raw === 'object' ? raw : {};
+                const success = data.success === true || data.deactivated === true;
+                return {
+                    success,
+                    message: success
+                        ? undefined
+                        : '라이선스 연결을 해제하지 못했습니다. 다시 시도해 주세요.',
+                };
+            },
+        });
+        const enrich = async (payload) => ({
+            ...payload,
+            deviceId: await getPersistentLicenseDeviceId(storage, prefix),
+        });
+        return {
+            verify: async (payload) => {
+                const storedKey = await storage.get(`${prefix}:licenseKey`);
+                const storedInstance = await storage.get(`${prefix}:instanceId`);
+                return http.verify(await enrich({
+                    ...payload,
+                    instanceId: payload.instanceId ||
+                        (storedKey === payload.licenseKey && typeof storedInstance === 'string'
+                            ? storedInstance
+                            : ''),
+                }));
+            },
+            validate: async (payload) => {
+                const enriched = await enrich(payload);
+                // Legacy users may not have a Lemon instance yet. Activate once;
+                // the server reuses its device mapping when a response was lost.
+                return payload.instanceId ? http.validate(enriched) : http.verify(enriched);
+            },
+            deactivate: async (payload) => http.deactivate(await enrich(payload)),
+        };
+    }
+
     class FigmaStorageAdapter {
         constructor(figma) {
             this.figma = figma;
@@ -1237,6 +1448,7 @@
     class FigmaLicenseStatusManager {
         constructor(options) {
             this.options = options;
+            this.messageQueue = Promise.resolve();
             this.messageTypes = {
                 ...DEFAULT_LICENSE_MESSAGE_TYPES,
                 ...(options.messageTypes || {}),
@@ -1246,6 +1458,7 @@
         async initialize() {
             if (!this.initializationPromise) {
                 this.initializationPromise = (async () => {
+                    await this.options.beforeInitialize?.();
                     const state = await this.options.core.initialize();
                     await this.postStatusUpdate(state);
                 })().catch((error) => {
@@ -1255,7 +1468,12 @@
             }
             await this.initializationPromise;
         }
-        async handleMessage(pluginMessage) {
+        handleMessage(pluginMessage) {
+            const operation = this.messageQueue.then(() => this.handleMessageNow(pluginMessage));
+            this.messageQueue = operation.then(() => undefined, () => undefined);
+            return operation;
+        }
+        async handleMessageNow(pluginMessage) {
             if (!pluginMessage || typeof pluginMessage !== 'object') {
                 return false;
             }
@@ -1269,15 +1487,18 @@
                 return true;
             }
             if (type === this.messageTypes.verifyLicense) {
+                await this.initialize();
                 const licenseKey = typeof message.licenseKey === 'string' ? message.licenseKey : '';
                 await this.handleVerifyLicense(licenseKey);
                 return true;
             }
             if (type === this.messageTypes.deactivateLicense) {
+                await this.initialize();
                 await this.handleDeactivateLicense();
                 return true;
             }
             if (type === this.messageTypes.checkFeatureAccess) {
+                await this.initialize();
                 const featureKey = typeof message.featureKey === 'string' ? message.featureKey : undefined;
                 const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
                     ? message.amount
@@ -1286,6 +1507,7 @@
                 return true;
             }
             if (type === this.messageTypes.consumeUsage) {
+                await this.initialize();
                 const amount = typeof message.amount === 'number' && Number.isFinite(message.amount) && message.amount > 0
                     ? message.amount
                     : 1;
@@ -1309,6 +1531,7 @@
          * This is the preferred guard for operations handled entirely in main.
          */
         async canUseFeature(featureKey, amount = 1) {
+            await this.initialize();
             const state = await this.options.core.getStatus();
             const safeAmount = Number.isFinite(amount) && amount > 0 ? amount : 1;
             return this.options.core.resolveUsageAccess(state, featureKey, safeAmount);
@@ -1317,6 +1540,7 @@
          * Consume usage from main code and publish the refreshed status to the UI.
          */
         async consumeUsage(amount = 1, featureKey) {
+            await this.initialize();
             const result = await this.options.core.consumeUsage(amount, featureKey);
             await this.postStatusUpdate(result.state);
             return result;
@@ -1453,14 +1677,21 @@
         const figmaApi = resolveFigmaApi(options.figma);
         const storage = options.storage ?? new FigmaStorageAdapter(figmaApi);
         const notifier = options.notifier ?? new FigmaNotifierAdapter(figmaApi);
-        const transport = options.transport ?? new FetchLicenseTransport({
-            verifyUrl: options.config.endpoint,
-            validateUrl: options.config.validateEndpoint,
-            deactivateUrl: options.config.deactivateEndpoint,
-            headers: options.config.requestHeaders,
-            timeoutMs: options.config.requestTimeoutMs,
-            fetchFn: options.fetchFn,
-        });
+        const prefix = options.config.storagePrefix?.trim() || `${options.config.instanceName}:${options.config.productId}`;
+        const transport = options.transport ?? (options.wordpress
+            ? createWordPressLicenseTransport({
+                baseUrl: options.wordpress.baseUrl, productId: options.config.productId,
+                storagePrefix: prefix, storage, fetchFn: options.fetchFn,
+                timeoutMs: options.config.requestTimeoutMs,
+            })
+            : new FetchLicenseTransport({
+                verifyUrl: options.config.endpoint,
+                validateUrl: options.config.validateEndpoint,
+                deactivateUrl: options.config.deactivateEndpoint,
+                headers: options.config.requestHeaders,
+                timeoutMs: options.config.requestTimeoutMs,
+                fetchFn: options.fetchFn,
+            }));
         const coreDependencies = {
             storage,
             transport,
@@ -1472,6 +1703,26 @@
             core,
             notifier,
             messageTypes: options.messageTypes,
+            beforeInitialize: options.migrateLegacyStorage
+                ? () => migrateLegacyLicenseStorage(storage, prefix, typeof options.migrateLegacyStorage === 'object' ? options.migrateLegacyStorage : undefined)
+                : undefined,
+        });
+    }
+    /** Shared membership + Lemon gateway setup. Product allowlists stay on the server. */
+    function createWordPressFigmaLicenseManager(options) {
+        const base = options.serverBaseUrl.replace(/\/$/, '');
+        return createFigmaLicenseStatusManager({
+            figma: options.figma, storage: options.storage, notifier: options.notifier,
+            fetchFn: options.fetchFn, messageTypes: options.messageTypes,
+            migrateLegacyStorage: options.migrateLegacyStorage ?? true,
+            wordpress: { baseUrl: base },
+            config: {
+                productId: options.productId, instanceName: options.instanceName || options.productId,
+                storagePrefix: options.storagePrefix || `designbase:${options.productId}`,
+                endpoint: `${base}/activate`, validateEndpoint: `${base}/validate`, deactivateEndpoint: `${base}/deactivate`,
+                requestTimeoutMs: options.timeoutMs || 20000,
+                policy: options.policy,
+            },
         });
     }
 
@@ -1486,10 +1737,15 @@
     exports.LicenseCoreError = LicenseCoreError;
     exports.LicenseTransportHttpError = LicenseTransportHttpError;
     exports.createFigmaLicenseStatusManager = createFigmaLicenseStatusManager;
+    exports.createWordPressFigmaLicenseManager = createWordPressFigmaLicenseManager;
+    exports.createWordPressLicenseTransport = createWordPressLicenseTransport;
     exports.defaultNormalizeDeactivateResponse = defaultNormalizeDeactivateResponse;
     exports.defaultNormalizeVerifyResponse = defaultNormalizeVerifyResponse;
+    exports.getPersistentLicenseDeviceId = getPersistentLicenseDeviceId;
     exports.isActivationLimitReached = isActivationLimitReached;
     exports.mapLicenseError = mapLicenseError;
+    exports.migrateLegacyLicenseStorage = migrateLegacyLicenseStorage;
+    exports.normalizeWordPressLicenseResponse = normalizeWordPressLicenseResponse;
 
 }));
 //# sourceMappingURL=index.umd.js.map