@designbasekorea/figma-license-core 0.1.0

package/dist/index.js

@@ -0,0 +1,649 @@
+'use strict';
+
+exports.LicenseErrorCode = void 0;
+(function (LicenseErrorCode) {
+    LicenseErrorCode["ACTIVATION_LIMIT_REACHED"] = "ACTIVATION_LIMIT_REACHED";
+    LicenseErrorCode["INVALID_LICENSE"] = "INVALID_LICENSE";
+    LicenseErrorCode["PRODUCT_MISMATCH"] = "PRODUCT_MISMATCH";
+    LicenseErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    LicenseErrorCode["STORAGE_ERROR"] = "STORAGE_ERROR";
+    LicenseErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
+    LicenseErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(exports.LicenseErrorCode || (exports.LicenseErrorCode = {}));
+class LicenseCoreError extends Error {
+    constructor(code, message, details, retriable = false) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.retriable = retriable;
+        this.name = 'LicenseCoreError';
+    }
+}
+
+function asText(input) {
+    if (!input) {
+        return '';
+    }
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof input === 'object' && 'message' in input) {
+        const maybeMessage = input.message;
+        if (typeof maybeMessage === 'string') {
+            return maybeMessage;
+        }
+    }
+    try {
+        return JSON.stringify(input);
+    }
+    catch {
+        return String(input);
+    }
+}
+function inferCode(text) {
+    const normalized = text.toLowerCase();
+    if (normalized.includes('activation limit')
+        || normalized.includes('seat')
+        || normalized.includes('too many activations')
+        || normalized.includes('already activated on maximum')) {
+        return exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED;
+    }
+    if (normalized.includes('invalid license')
+        || normalized.includes('not found')
+        || normalized.includes('not valid')
+        || normalized.includes('license key is invalid')) {
+        return exports.LicenseErrorCode.INVALID_LICENSE;
+    }
+    if (normalized.includes('product mismatch') || normalized.includes('wrong product')) {
+        return exports.LicenseErrorCode.PRODUCT_MISMATCH;
+    }
+    if (normalized.includes('network')
+        || normalized.includes('fetch')
+        || normalized.includes('timeout')
+        || normalized.includes('failed to connect')) {
+        return exports.LicenseErrorCode.NETWORK_ERROR;
+    }
+    if (normalized.includes('500') || normalized.includes('502') || normalized.includes('503')) {
+        return exports.LicenseErrorCode.SERVER_ERROR;
+    }
+    return exports.LicenseErrorCode.UNKNOWN_ERROR;
+}
+function mapLicenseError(error, fallbackMessage = '라이선스 처리 중 알 수 없는 오류가 발생했습니다.') {
+    if (error instanceof LicenseCoreError) {
+        return error;
+    }
+    const text = asText(error);
+    const message = text.trim() || fallbackMessage;
+    const code = inferCode(message);
+    return new LicenseCoreError(code, message, error, code === exports.LicenseErrorCode.NETWORK_ERROR || code === exports.LicenseErrorCode.SERVER_ERROR);
+}
+function isActivationLimitReached(activationLimit, activationUsage) {
+    if (activationLimit <= 0) {
+        return false;
+    }
+    return activationUsage >= activationLimit;
+}
+
+const STORAGE_KEYS = {
+    paymentStatus: 'paymentStatus',
+    licenseKey: 'licenseKey',
+    activationLimit: 'activationLimit',
+    activationUsage: 'activationUsage',
+    usageCount: 'usageCount',
+    lastVerifiedAt: 'lastVerifiedAt',
+};
+const DEFAULT_USAGE_LIMIT = 20;
+const MASTER_CODE_ACTIVATION_LIMIT = 999999;
+function toNonNegativeNumber(value, fallback = 0) {
+    if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric) && numeric >= 0) {
+            return numeric;
+        }
+    }
+    return fallback;
+}
+function toText(value) {
+    return typeof value === 'string' ? value : '';
+}
+function toPaymentStatus(value) {
+    if (value === 'PAID' || value === 'UNPAID' || value === 'FREE') {
+        return value;
+    }
+    return 'FREE';
+}
+function normalizeProductId(productId) {
+    return productId.trim().toLowerCase();
+}
+class LicenseCore {
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+        if (!config.productId.trim()) {
+            throw new Error('LicenseConfig.productId is required.');
+        }
+        if (!config.endpoint.trim()) {
+            throw new Error('LicenseConfig.endpoint is required.');
+        }
+        if (!config.instanceName.trim()) {
+            throw new Error('LicenseConfig.instanceName is required.');
+        }
+        this.usageLimit = Math.max(config.usageLimit ?? DEFAULT_USAGE_LIMIT, 0);
+        this.storagePrefix = config.storagePrefix?.trim() || `${config.instanceName}:${config.productId}`;
+    }
+    async initialize() {
+        return this.loadState();
+    }
+    async getStatus() {
+        return this.loadState();
+    }
+    async verifyLicense(licenseKey) {
+        const trimmedLicenseKey = licenseKey.trim();
+        if (!trimmedLicenseKey) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.INVALID_LICENSE, '라이선스 키를 입력해 주세요.');
+        }
+        if (this.config.masterCode && trimmedLicenseKey === this.config.masterCode) {
+            const current = await this.loadState();
+            const nextState = {
+                ...current,
+                paymentStatus: 'PAID',
+                licenseKey: trimmedLicenseKey,
+                activationLimit: MASTER_CODE_ACTIVATION_LIMIT,
+                activationUsage: 0,
+                lastVerifiedAt: new Date().toISOString(),
+            };
+            await this.persistState(nextState);
+            await this.notify('마스터 코드로 라이선스가 활성화되었습니다.');
+            return nextState;
+        }
+        let verifyResult;
+        try {
+            verifyResult = await this.deps.transport.verify({
+                licenseKey: trimmedLicenseKey,
+                productId: this.config.productId,
+                instanceName: this.config.instanceName,
+            });
+        }
+        catch (error) {
+            throw mapLicenseError(error, '라이선스 검증 요청에 실패했습니다.');
+        }
+        if (!verifyResult.valid) {
+            throw mapLicenseError(verifyResult.raw ?? verifyResult.message, '유효하지 않은 라이선스 키입니다.');
+        }
+        if (verifyResult.productId
+            && normalizeProductId(verifyResult.productId) !== normalizeProductId(this.config.productId)) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.PRODUCT_MISMATCH, '현재 플러그인과 라이선스 상품이 일치하지 않습니다.', verifyResult);
+        }
+        const activationLimit = toNonNegativeNumber(verifyResult.activationLimit, 0);
+        const activationUsage = toNonNegativeNumber(verifyResult.activationUsage, 0);
+        if (isActivationLimitReached(activationLimit, activationUsage)) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.ACTIVATION_LIMIT_REACHED, '활성화 가능한 기기 수를 모두 사용했습니다. 기존 기기를 비활성화한 뒤 다시 시도해 주세요.', verifyResult);
+        }
+        const current = await this.loadState();
+        const nextState = {
+            ...current,
+            paymentStatus: 'PAID',
+            licenseKey: trimmedLicenseKey,
+            activationLimit,
+            activationUsage,
+            lastVerifiedAt: new Date().toISOString(),
+        };
+        await this.persistState(nextState);
+        await this.notify(verifyResult.message || '라이선스가 활성화되었습니다.');
+        return nextState;
+    }
+    async deactivateLicense() {
+        const current = await this.loadState();
+        if (!current.licenseKey) {
+            return current;
+        }
+        const requestPayload = {
+            licenseKey: current.licenseKey,
+            productId: this.config.productId,
+            instanceName: this.config.instanceName,
+        };
+        if (!this.config.masterCode || current.licenseKey !== this.config.masterCode) {
+            try {
+                const deactivateResult = await this.deps.transport.deactivate(requestPayload);
+                if (!deactivateResult.success) {
+                    throw mapLicenseError(deactivateResult.raw ?? deactivateResult.message, '라이선스 비활성화에 실패했습니다.');
+                }
+            }
+            catch (error) {
+                throw mapLicenseError(error, '라이선스 비활성화 요청에 실패했습니다.');
+            }
+        }
+        const nextState = {
+            ...current,
+            paymentStatus: 'FREE',
+            licenseKey: '',
+            activationLimit: 0,
+            activationUsage: 0,
+            lastVerifiedAt: undefined,
+        };
+        await this.persistState(nextState);
+        await this.notify('라이선스가 비활성화되었습니다.');
+        return nextState;
+    }
+    async incrementUsage(amount = 1) {
+        const current = await this.loadState();
+        if (current.paymentStatus === 'PAID') {
+            return current;
+        }
+        const increasedAmount = Math.max(0, amount);
+        const nextState = {
+            ...current,
+            usageCount: current.usageCount + increasedAmount,
+        };
+        await this.persistState(nextState);
+        return nextState;
+    }
+    async canUseFeature() {
+        const state = await this.loadState();
+        return this.resolveUsageAccess(state);
+    }
+    resolveUsageAccess(state) {
+        if (state.paymentStatus === 'PAID') {
+            return {
+                allowed: true,
+                remaining: Number.POSITIVE_INFINITY,
+            };
+        }
+        const remaining = Math.max(this.usageLimit - state.usageCount, 0);
+        return {
+            allowed: remaining > 0,
+            remaining,
+        };
+    }
+    getUsageLimit() {
+        return this.usageLimit;
+    }
+    getStoragePrefix() {
+        return this.storagePrefix;
+    }
+    storageKey(name) {
+        return `${this.storagePrefix}:${STORAGE_KEYS[name]}`;
+    }
+    async loadState() {
+        try {
+            const [paymentStatus, licenseKey, activationLimit, activationUsage, usageCount, lastVerifiedAt,] = await Promise.all([
+                this.deps.storage.get(this.storageKey('paymentStatus')),
+                this.deps.storage.get(this.storageKey('licenseKey')),
+                this.deps.storage.get(this.storageKey('activationLimit')),
+                this.deps.storage.get(this.storageKey('activationUsage')),
+                this.deps.storage.get(this.storageKey('usageCount')),
+                this.deps.storage.get(this.storageKey('lastVerifiedAt')),
+            ]);
+            return {
+                paymentStatus: toPaymentStatus(paymentStatus),
+                licenseKey: toText(licenseKey),
+                activationLimit: toNonNegativeNumber(activationLimit, 0),
+                activationUsage: toNonNegativeNumber(activationUsage, 0),
+                usageCount: toNonNegativeNumber(usageCount, 0),
+                lastVerifiedAt: toText(lastVerifiedAt) || undefined,
+            };
+        }
+        catch (error) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.STORAGE_ERROR, '라이선스 상태를 불러오지 못했습니다.', error, true);
+        }
+    }
+    async persistState(state) {
+        try {
+            await Promise.all([
+                this.deps.storage.set(this.storageKey('paymentStatus'), state.paymentStatus),
+                this.deps.storage.set(this.storageKey('licenseKey'), state.licenseKey),
+                this.deps.storage.set(this.storageKey('activationLimit'), state.activationLimit),
+                this.deps.storage.set(this.storageKey('activationUsage'), state.activationUsage),
+                this.deps.storage.set(this.storageKey('usageCount'), state.usageCount),
+                this.deps.storage.set(this.storageKey('lastVerifiedAt'), state.lastVerifiedAt || ''),
+            ]);
+        }
+        catch (error) {
+            throw new LicenseCoreError(exports.LicenseErrorCode.STORAGE_ERROR, '라이선스 상태를 저장하지 못했습니다.', error, true);
+        }
+    }
+    async notify(message) {
+        if (!this.deps.notifier) {
+            return;
+        }
+        try {
+            await this.deps.notifier.notify(message);
+        }
+        catch {
+            // Notification failures should not break license flow.
+        }
+    }
+}
+
+function readTextField(raw, keys) {
+    if (!raw || typeof raw !== 'object') {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = raw[key];
+        if (typeof value === 'string' && value.trim()) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNumberField(raw, keys) {
+    if (!raw || typeof raw !== 'object') {
+        return undefined;
+    }
+    for (const key of keys) {
+        const value = raw[key];
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim() !== '') {
+            const numeric = Number(value);
+            if (Number.isFinite(numeric)) {
+                return numeric;
+            }
+        }
+    }
+    return undefined;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function defaultNormalizeVerifyResponse(raw) {
+    const body = asRecord(raw);
+    const valid = Boolean(body.valid
+        ?? body.success
+        ?? body.active
+        ?? (typeof body.status === 'string' && body.status.toLowerCase() === 'active'));
+    const message = readTextField(body, ['message', 'error', 'detail']);
+    const nestedLicenseKey = asRecord(body.license_key);
+    const nestedMeta = asRecord(body.meta);
+    const productId = readTextField(body, ['productId', 'product_id'])
+        || readTextField(nestedMeta, ['product_id'])
+        || readTextField(nestedLicenseKey, ['product_id']);
+    const activationLimit = readNumberField(body, ['activationLimit', 'activation_limit'])
+        ?? readNumberField(nestedMeta, ['activation_limit'])
+        ?? readNumberField(nestedLicenseKey, ['activation_limit']);
+    const activationUsage = readNumberField(body, ['activationUsage', 'activation_usage'])
+        ?? readNumberField(nestedMeta, ['activation_usage'])
+        ?? readNumberField(nestedLicenseKey, ['activation_usage']);
+    return {
+        valid,
+        message,
+        productId,
+        activationLimit,
+        activationUsage,
+        raw,
+    };
+}
+function defaultNormalizeDeactivateResponse(raw) {
+    const body = asRecord(raw);
+    const success = Boolean(body.success
+        ?? body.deactivated
+        ?? body.valid
+        ?? (typeof body.status === 'string' && ['ok', 'success', 'deactivated'].includes(body.status.toLowerCase())));
+    return {
+        success,
+        message: readTextField(body, ['message', 'error', 'detail']),
+        raw,
+    };
+}
+class FetchLicenseTransport {
+    constructor(config) {
+        this.config = config;
+        if (!config.verifyUrl.trim()) {
+            throw new Error('FetchLicenseTransport.verifyUrl is required.');
+        }
+        this.fetchFn = config.fetchFn ?? fetch;
+    }
+    async verify(payload) {
+        const raw = await this.postJson(this.config.verifyUrl, this.config.buildVerifyBody ? this.config.buildVerifyBody(payload) : payload);
+        const normalize = this.config.normalizeVerifyResponse ?? defaultNormalizeVerifyResponse;
+        return normalize(raw);
+    }
+    async deactivate(payload) {
+        const url = this.config.deactivateUrl || this.config.verifyUrl;
+        const body = this.config.buildDeactivateBody
+            ? this.config.buildDeactivateBody(payload)
+            : {
+                action: 'deactivate',
+                ...payload,
+            };
+        const raw = await this.postJson(url, body);
+        const normalize = this.config.normalizeDeactivateResponse ?? defaultNormalizeDeactivateResponse;
+        return normalize(raw);
+    }
+    async postJson(url, body) {
+        const timeoutMs = this.config.timeoutMs ?? 15000;
+        const abortController = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
+        const timeoutId = abortController
+            ? setTimeout(() => abortController.abort(), timeoutMs)
+            : undefined;
+        try {
+            const response = await this.fetchFn(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.config.headers || {}),
+                },
+                body: JSON.stringify(body),
+                signal: abortController?.signal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+            }
+            return await response.json();
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+
+class FigmaStorageAdapter {
+    constructor(figma) {
+        this.figma = figma;
+    }
+    async get(key) {
+        const value = await this.figma.clientStorage.getAsync(key);
+        return value;
+    }
+    async set(key, value) {
+        await this.figma.clientStorage.setAsync(key, value);
+    }
+    async delete(key) {
+        if (this.figma.clientStorage.deleteAsync) {
+            await this.figma.clientStorage.deleteAsync(key);
+            return;
+        }
+        await this.figma.clientStorage.setAsync(key, undefined);
+    }
+}
+class FigmaNotifierAdapter {
+    constructor(figma) {
+        this.figma = figma;
+    }
+    notify(message, options) {
+        if (this.figma.notify) {
+            this.figma.notify(message, options);
+        }
+    }
+}
+const DEFAULT_MESSAGE_TYPES = {
+    initialize: 'initialize',
+    verifyLicense: 'verify-license',
+    deactivateLicense: 'deactivate-license',
+    updateStatus: 'update-plugin-status',
+    verifyResult: 'license-verification-result',
+    deactivateResult: 'license-deactivation-result',
+};
+class FigmaLicenseStatusManager {
+    constructor(options) {
+        this.options = options;
+        this.messageTypes = {
+            ...DEFAULT_MESSAGE_TYPES,
+            ...(options.messageTypes || {}),
+        };
+        this.notifier = options.notifier;
+    }
+    async initialize() {
+        await this.postStatusUpdate();
+    }
+    async handleMessage(pluginMessage) {
+        if (!pluginMessage || typeof pluginMessage !== 'object') {
+            return false;
+        }
+        const message = pluginMessage;
+        const type = typeof message.type === 'string' ? message.type : '';
+        if (!type) {
+            return false;
+        }
+        if (type === this.messageTypes.initialize) {
+            await this.postStatusUpdate();
+            return true;
+        }
+        if (type === this.messageTypes.verifyLicense) {
+            const licenseKey = typeof message.licenseKey === 'string' ? message.licenseKey : '';
+            await this.handleVerifyLicense(licenseKey);
+            return true;
+        }
+        if (type === this.messageTypes.deactivateLicense) {
+            await this.handleDeactivateLicense();
+            return true;
+        }
+        return false;
+    }
+    bindToOnMessage(fallbackHandler) {
+        const previousHandler = fallbackHandler ?? this.options.figma.ui.onmessage;
+        this.options.figma.ui.onmessage = async (pluginMessage) => {
+            const handled = await this.handleMessage(pluginMessage);
+            if (!handled && previousHandler) {
+                await previousHandler(pluginMessage);
+            }
+        };
+    }
+    async handleVerifyLicense(licenseKey) {
+        try {
+            const state = await this.options.core.verifyLicense(licenseKey);
+            const access = this.options.core.resolveUsageAccess(state);
+            this.postMessage({
+                type: this.messageTypes.verifyResult,
+                success: true,
+                message: '라이선스가 검증되었습니다.',
+                ...state,
+                usageLimit: this.options.core.getUsageLimit(),
+                canUseFeature: access.allowed,
+                remainingUsage: access.remaining,
+            });
+            await this.postStatusUpdate(state);
+        }
+        catch (error) {
+            const mappedError = mapLicenseError(error, '라이선스 검증 중 오류가 발생했습니다.');
+            await this.notifyError(mappedError);
+            this.postMessage({
+                type: this.messageTypes.verifyResult,
+                success: false,
+                message: mappedError.message,
+                errorCode: mappedError.code,
+            });
+        }
+    }
+    async handleDeactivateLicense() {
+        try {
+            const state = await this.options.core.deactivateLicense();
+            const access = this.options.core.resolveUsageAccess(state);
+            this.postMessage({
+                type: this.messageTypes.deactivateResult,
+                success: true,
+                message: '라이선스가 비활성화되었습니다.',
+                ...state,
+                usageLimit: this.options.core.getUsageLimit(),
+                canUseFeature: access.allowed,
+                remainingUsage: access.remaining,
+            });
+            await this.postStatusUpdate(state);
+        }
+        catch (error) {
+            const mappedError = mapLicenseError(error, '라이선스 비활성화 중 오류가 발생했습니다.');
+            await this.notifyError(mappedError);
+            this.postMessage({
+                type: this.messageTypes.deactivateResult,
+                success: false,
+                message: mappedError.message,
+                errorCode: mappedError.code,
+            });
+        }
+    }
+    async postStatusUpdate(initialState) {
+        const state = initialState ?? await this.options.core.getStatus();
+        const access = this.options.core.resolveUsageAccess(state);
+        this.postMessage({
+            type: this.messageTypes.updateStatus,
+            ...state,
+            usageLimit: this.options.core.getUsageLimit(),
+            canUseFeature: access.allowed,
+            remainingUsage: access.remaining,
+        });
+    }
+    postMessage(message) {
+        this.options.figma.ui.postMessage(message);
+    }
+    async notifyError(error) {
+        if (!this.notifier) {
+            return;
+        }
+        await this.notifier.notify(error.message, { error: true });
+    }
+}
+function resolveFigmaApi(figma) {
+    if (figma) {
+        return figma;
+    }
+    const globalObject = globalThis;
+    if (globalObject.figma) {
+        return globalObject.figma;
+    }
+    throw new Error('Figma API instance is required. Pass options.figma or run in Figma environment.');
+}
+function createFigmaLicenseStatusManager(options) {
+    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,
+        deactivateUrl: options.config.deactivateEndpoint,
+        headers: options.config.requestHeaders,
+        timeoutMs: options.config.requestTimeoutMs,
+        fetchFn: options.fetchFn,
+    });
+    const coreDependencies = {
+        storage,
+        transport,
+        notifier,
+    };
+    const core = new LicenseCore(options.config, coreDependencies);
+    return new FigmaLicenseStatusManager({
+        figma: figmaApi,
+        core,
+        notifier,
+        messageTypes: options.messageTypes,
+    });
+}
+
+exports.FetchLicenseTransport = FetchLicenseTransport;
+exports.FigmaLicenseStatusManager = FigmaLicenseStatusManager;
+exports.FigmaNotifierAdapter = FigmaNotifierAdapter;
+exports.FigmaStorageAdapter = FigmaStorageAdapter;
+exports.LicenseCore = LicenseCore;
+exports.LicenseCoreError = LicenseCoreError;
+exports.createFigmaLicenseStatusManager = createFigmaLicenseStatusManager;
+exports.defaultNormalizeDeactivateResponse = defaultNormalizeDeactivateResponse;
+exports.defaultNormalizeVerifyResponse = defaultNormalizeVerifyResponse;
+exports.isActivationLimitReached = isActivationLimitReached;
+exports.mapLicenseError = mapLicenseError;
+//# sourceMappingURL=index.js.map