devextreme/cjs/__internal/core/license/license_validation.js

JavaScript/TypeScript Component Suite for Responsive Web Development

/**
 * DevExtreme (cjs/__internal/core/license/license_validation.js)
 * Version: 26.1.3
 * Build date: Wed Jun 10 2026
 *
 * Copyright (c) 2012 - 2026 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */
"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = void 0;
exports.parseLicenseKey = parseLicenseKey;
exports.peekValidationPerformed = peekValidationPerformed;
exports.setLicenseCheckSkipCondition = setLicenseCheckSkipCondition;
exports.validateLicense = validateLicense;
var _config = _interopRequireDefault(require("../../../core/config"));
var _errors = _interopRequireDefault(require("../../../core/errors"));
var _version = require("../../../core/version");
var _version2 = require("../../utils/version");
var _const = require("./const");
var _lcp_key_validator = require("./lcp_key_validation/lcp_key_validator");
var _license_warnings = require("./license_warnings");
var _trial_panel = require("./trial_panel");
var _types = require("./types");

function _interopRequireDefault(e) {
    return e && e.__esModule ? e : {
        default: e
    }
}
let validationPerformed = false;

function parseLicenseKey(encodedKey) {
    if (void 0 === encodedKey) {
        return _types.GENERAL_ERROR
    }
    if ((0, _lcp_key_validator.isProductOnlyLicense)(encodedKey)) {
        return (0, _lcp_key_validator.parseDevExpressProductKey)(encodedKey)
    }
    return _types.GENERAL_ERROR
}

function isPreview(patch) {
    return isNaN(patch) || patch < _const.RTM_MIN_PATCH_VERSION
}

function hasLicensePrefix(licenseKey, prefix) {
    return licenseKey.trim().startsWith(prefix)
}

function displayTrialPanel() {
    const buyNowLink = (0, _config.default)().buyNowLink ?? _const.BUY_NOW_LINK;
    const licensingDocLink = (0, _config.default)().licensingDocLink ?? _const.LICENSING_DOC_LINK;
    (0, _trial_panel.showTrialPanel)(buyNowLink, licensingDocLink, _version.fullVersion, _const.SUBSCRIPTION_NAMES)
}

function getLicenseCheckParams(_ref) {
    let {
        licenseKey: licenseKey,
        version: version
    } = _ref;
    let preview = false;
    try {
        preview = isPreview(version.patch);
        const {
            major: major,
            minor: minor
        } = version;
        if (!licenseKey || licenseKey === _const.LICENSE_KEY_PLACEHOLDER) {
            return {
                preview: preview,
                error: "W0019",
                warningType: "no-key"
            }
        }
        if (hasLicensePrefix(licenseKey, "LCX")) {
            return {
                preview: preview,
                error: "W0021",
                warningType: "lcx-used"
            }
        }
        if (hasLicensePrefix(licenseKey, "ewog")) {
            return {
                preview: preview,
                error: "W0021",
                warningType: "old-devextreme-key"
            }
        }
        const license = parseLicenseKey(licenseKey);
        if (license.kind === _types.TokenKind.corrupted) {
            if ("product-kind" === license.error) {
                return {
                    preview: preview,
                    error: "W0021",
                    warningType: "no-devextreme-license"
                }
            }
            return {
                preview: preview,
                error: "W0021",
                warningType: "invalid-key"
            }
        }
        if (license.kind !== _types.TokenKind.verified) {
            return {
                preview: preview,
                error: "W0021",
                warningType: "invalid-key"
            }
        }
        if (!(major && minor)) {
            return {
                preview: preview,
                error: "W0021",
                warningType: "invalid-key"
            }
        }
        if (10 * major + minor > license.payload.maxVersionAllowed) {
            return {
                preview: preview,
                error: "W0020",
                warningType: "version-mismatch",
                maxVersionAllowed: license.payload.maxVersionAllowed
            }
        }
        return {
            preview: preview,
            error: void 0
        }
    } catch {
        return {
            preview: preview,
            error: "W0021",
            warningType: "invalid-key"
        }
    }
}

function validateLicense(licenseKey) {
    let versionStr = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : _version.fullVersion;
    if (validationPerformed) {
        return
    }
    validationPerformed = true;
    const version = (0, _version2.parseVersion)(versionStr);
    (0, _version2.assertedVersionsCompatible)(version);
    const {
        error: error,
        warningType: warningType,
        maxVersionAllowed: maxVersionAllowed
    } = getLicenseCheckParams({
        licenseKey: licenseKey,
        version: version
    });
    if (error) {
        displayTrialPanel()
    }
    if (error) {
        if (warningType) {
            const versionInfo = "version-mismatch" === warningType && void 0 !== maxVersionAllowed ? {
                keyVersion: `${Math.floor(maxVersionAllowed/10)}.${maxVersionAllowed%10}`,
                requiredVersion: `${version.major}.${version.minor}`
            } : void 0;
            (0, _license_warnings.logLicenseWarning)(warningType, versionStr, versionInfo)
        } else {
            _errors.default.log(error)
        }
    }
}

function peekValidationPerformed() {
    return validationPerformed
}

function setLicenseCheckSkipCondition() {}
var _default = exports.default = {
    validateLicense: validateLicense
};