@mui/x-license 7.0.0-beta.2

package/modern/verifyLicense/verifyLicense.js

@@ -0,0 +1,159 @@
+import { base64Decode, base64Encode } from '../encoding/base64';
+import { md5 } from '../encoding/md5';
+import { LICENSE_STATUS } from '../utils/licenseStatus';
+import { LICENSE_SCOPES } from '../utils/licenseScope';
+import { LICENSING_MODELS } from '../utils/licensingModel';
+const getDefaultReleaseDate = () => {
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  return today;
+};
+export function generateReleaseInfo(releaseDate = getDefaultReleaseDate()) {
+  return base64Encode(releaseDate.getTime().toString());
+}
+const expiryReg = /^.*EXPIRY=([0-9]+),.*$/;
+/**
+ * Format: ORDER:${orderNumber},EXPIRY=${expiryTimestamp},KEYVERSION=1
+ */
+const decodeLicenseVersion1 = license => {
+  let expiryTimestamp;
+  try {
+    expiryTimestamp = parseInt(license.match(expiryReg)[1], 10);
+    if (!expiryTimestamp || Number.isNaN(expiryTimestamp)) {
+      expiryTimestamp = null;
+    }
+  } catch (err) {
+    expiryTimestamp = null;
+  }
+  return {
+    scope: 'pro',
+    licensingModel: 'perpetual',
+    expiryTimestamp
+  };
+};
+
+/**
+ * Format: O=${orderNumber},E=${expiryTimestamp},S=${scope},LM=${licensingModel},KV=2`;
+ */
+const decodeLicenseVersion2 = license => {
+  const licenseInfo = {
+    scope: null,
+    licensingModel: null,
+    expiryTimestamp: null
+  };
+  license.split(',').map(token => token.split('=')).filter(el => el.length === 2).forEach(([key, value]) => {
+    if (key === 'S') {
+      licenseInfo.scope = value;
+    }
+    if (key === 'LM') {
+      licenseInfo.licensingModel = value;
+    }
+    if (key === 'E') {
+      const expiryTimestamp = parseInt(value, 10);
+      if (expiryTimestamp && !Number.isNaN(expiryTimestamp)) {
+        licenseInfo.expiryTimestamp = expiryTimestamp;
+      }
+    }
+  });
+  return licenseInfo;
+};
+
+/**
+ * Decode the license based on its key version and return a version-agnostic `MuiLicense` object.
+ */
+const decodeLicense = encodedLicense => {
+  const license = base64Decode(encodedLicense);
+  if (license.includes('KEYVERSION=1')) {
+    return decodeLicenseVersion1(license);
+  }
+  if (license.includes('KV=2')) {
+    return decodeLicenseVersion2(license);
+  }
+  return null;
+};
+export function verifyLicense({
+  releaseInfo,
+  licenseKey,
+  acceptedScopes
+}) {
+  if (!releaseInfo) {
+    throw new Error('MUI X: The release information is missing. Not able to validate license.');
+  }
+  if (!licenseKey) {
+    return {
+      status: LICENSE_STATUS.NotFound
+    };
+  }
+  const hash = licenseKey.substr(0, 32);
+  const encoded = licenseKey.substr(32);
+  if (hash !== md5(encoded)) {
+    return {
+      status: LICENSE_STATUS.Invalid
+    };
+  }
+  const license = decodeLicense(encoded);
+  if (license == null) {
+    console.error('MUI X: Error checking license. Key version not found!');
+    return {
+      status: LICENSE_STATUS.Invalid
+    };
+  }
+  if (license.licensingModel == null || !LICENSING_MODELS.includes(license.licensingModel)) {
+    console.error('MUI X: Error checking license. Licensing model not found or invalid!');
+    return {
+      status: LICENSE_STATUS.Invalid
+    };
+  }
+  if (license.expiryTimestamp == null) {
+    console.error('MUI X: Error checking license. Expiry timestamp not found or invalid!');
+    return {
+      status: LICENSE_STATUS.Invalid
+    };
+  }
+  if (license.licensingModel === 'perpetual' || process.env.NODE_ENV === 'production') {
+    const pkgTimestamp = parseInt(base64Decode(releaseInfo), 10);
+    if (Number.isNaN(pkgTimestamp)) {
+      throw new Error('MUI X: The release information is invalid. Not able to validate license.');
+    }
+    if (license.expiryTimestamp < pkgTimestamp) {
+      return {
+        status: LICENSE_STATUS.ExpiredVersion
+      };
+    }
+  } else if (license.licensingModel === 'subscription' || license.licensingModel === 'annual') {
+    if (new Date().getTime() > license.expiryTimestamp) {
+      if (
+      // 30 days grace
+      new Date().getTime() < license.expiryTimestamp + 1000 * 3600 * 24 * 30 || process.env.NODE_ENV !== 'development') {
+        return {
+          status: LICENSE_STATUS.ExpiredAnnualGrace,
+          meta: {
+            expiryTimestamp: license.expiryTimestamp,
+            licenseKey
+          }
+        };
+      }
+      return {
+        status: LICENSE_STATUS.ExpiredAnnual,
+        meta: {
+          expiryTimestamp: license.expiryTimestamp,
+          licenseKey
+        }
+      };
+    }
+  }
+  if (license.scope == null || !LICENSE_SCOPES.includes(license.scope)) {
+    console.error('Error checking license. scope not found or invalid!');
+    return {
+      status: LICENSE_STATUS.Invalid
+    };
+  }
+  if (!acceptedScopes.includes(license.scope)) {
+    return {
+      status: LICENSE_STATUS.OutOfScope
+    };
+  }
+  return {
+    status: LICENSE_STATUS.Valid
+  };
+}

package/node/Unstable_LicenseInfoProvider/LicenseInfoContext.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = /*#__PURE__*/React.createContext({
+  key: undefined
+});

package/node/Unstable_LicenseInfoProvider/LicenseInfoProvider.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LicenseInfoProvider = LicenseInfoProvider;
+var React = _interopRequireWildcard(require("react"));
+var _LicenseInfoContext = _interopRequireDefault(require("./LicenseInfoContext"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * @ignore - do not document.
+ */
+
+/**
+ * @ignore - do not document.
+ */
+function LicenseInfoProvider({
+  info,
+  children
+}) {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LicenseInfoContext.default.Provider, {
+    value: info,
+    children: children
+  });
+}

package/node/Unstable_LicenseInfoProvider/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Unstable_LicenseInfoProvider", {
+  enumerable: true,
+  get: function () {
+    return _LicenseInfoProvider.LicenseInfoProvider;
+  }
+});
+var _LicenseInfoProvider = require("./LicenseInfoProvider");

package/node/Watermark/Watermark.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Watermark = Watermark;
+var React = _interopRequireWildcard(require("react"));
+var _useLicenseVerifier = require("../useLicenseVerifier");
+var _licenseStatus = require("../utils/licenseStatus");
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function getLicenseErrorMessage(licenseStatus) {
+  switch (licenseStatus) {
+    case _licenseStatus.LICENSE_STATUS.ExpiredAnnualGrace:
+    case _licenseStatus.LICENSE_STATUS.ExpiredAnnual:
+      return 'MUI X Expired license key';
+    case _licenseStatus.LICENSE_STATUS.ExpiredVersion:
+      return 'MUI X Expired package version';
+    case _licenseStatus.LICENSE_STATUS.Invalid:
+      return 'MUI X Invalid license key';
+    case _licenseStatus.LICENSE_STATUS.OutOfScope:
+      return 'MUI X License key plan mismatch';
+    case _licenseStatus.LICENSE_STATUS.NotFound:
+      return 'MUI X Missing license key';
+    default:
+      throw new Error('Unhandled MUI X license status.');
+  }
+}
+function Watermark(props) {
+  const {
+    packageName,
+    releaseInfo
+  } = props;
+  const licenseStatus = (0, _useLicenseVerifier.useLicenseVerifier)(packageName, releaseInfo);
+  if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.Valid) {
+    return null;
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    style: {
+      position: 'absolute',
+      pointerEvents: 'none',
+      color: '#8282829e',
+      zIndex: 100000,
+      width: '100%',
+      textAlign: 'center',
+      bottom: '50%',
+      right: 0,
+      letterSpacing: 5,
+      fontSize: 24
+    },
+    children: getLicenseErrorMessage(licenseStatus.status)
+  });
+}

package/node/Watermark/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Watermark = require("./Watermark");
+Object.keys(_Watermark).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Watermark[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Watermark[key];
+    }
+  });
+});

package/node/encoding/base64.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.base64Encode = exports.base64Decode = void 0;
+/* eslint-disable */
+const _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+function utf8Encode(str) {
+  for (let n = 0; n < str.length; n++) {
+    const c = str.charCodeAt(n);
+    if (c >= 128) {
+      throw new Error('ASCII only support');
+    }
+  }
+  return str;
+}
+const base64Decode = input => {
+  let output = '';
+  let chr1, chr2, chr3;
+  let enc1, enc2, enc3, enc4;
+  let i = 0;
+  input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+  while (i < input.length) {
+    enc1 = _keyStr.indexOf(input.charAt(i++));
+    enc2 = _keyStr.indexOf(input.charAt(i++));
+    enc3 = _keyStr.indexOf(input.charAt(i++));
+    enc4 = _keyStr.indexOf(input.charAt(i++));
+    chr1 = enc1 << 2 | enc2 >> 4;
+    chr2 = (enc2 & 15) << 4 | enc3 >> 2;
+    chr3 = (enc3 & 3) << 6 | enc4;
+    output = output + String.fromCharCode(chr1);
+    if (enc3 != 64) {
+      output = output + String.fromCharCode(chr2);
+    }
+    if (enc4 != 64) {
+      output = output + String.fromCharCode(chr3);
+    }
+  }
+  return output;
+};
+exports.base64Decode = base64Decode;
+const base64Encode = input => {
+  let output = '';
+  let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+  let i = 0;
+  input = utf8Encode(input);
+  while (i < input.length) {
+    chr1 = input.charCodeAt(i++);
+    chr2 = input.charCodeAt(i++);
+    chr3 = input.charCodeAt(i++);
+    enc1 = chr1 >> 2;
+    enc2 = (chr1 & 3) << 4 | chr2 >> 4;
+    enc3 = (chr2 & 15) << 2 | chr3 >> 6;
+    enc4 = chr3 & 63;
+    if (isNaN(chr2)) {
+      enc3 = enc4 = 64;
+    } else if (isNaN(chr3)) {
+      enc4 = 64;
+    }
+    output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+  }
+  return output;
+};
+exports.base64Encode = base64Encode;

package/node/encoding/md5.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.md5 = md5;
+/* eslint-disable */
+// See "precomputation" in notes
+const k = [];
+let i = 0;
+for (; i < 64;) {
+  k[i] = 0 | Math.sin(++i % Math.PI) * 4294967296;
+  // k[i] = 0 | (Math.abs(Math.sin(++i)) * 4294967296);
+}
+function md5(s) {
+  const words = [];
+  let b,
+    c,
+    d,
+    j = unescape(encodeURI(s)) + '\x80',
+    a = j.length;
+  const h = [b = 0x67452301, c = 0xefcdab89, ~b, ~c];
+  s = --a / 4 + 2 | 15;
+
+  // See "Length bits" in notes
+  words[--s] = a * 8;
+  for (; ~a;) {
+    // a !== -1
+    words[a >> 2] |= j.charCodeAt(a) << 8 * a--;
+  }
+  for (i = j = 0; i < s; i += 16) {
+    a = h;
+    for (; j < 64; a = [d = a[3], b + ((d = a[0] + [b & c | ~b & d, d & b | ~d & c, b ^ c ^ d, c ^ (b | ~d)][a = j >> 4] + k[j] + ~~words[i | [j, 5 * j + 1, 3 * j + 5, 7 * j][a] & 15]) << (a = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21][4 * a + j++ % 4]) | d >>> -a), b, c]) {
+      b = a[1] | 0;
+      c = a[2];
+    }
+
+    // See "Integer safety" in notes
+    for (j = 4; j;) h[--j] += a[j];
+
+    // j === 0
+  }
+  for (s = ''; j < 32;) {
+    s += (h[j >> 3] >> (1 ^ j++) * 4 & 15).toString(16);
+    // s += ((h[j >> 3] >> (4 ^ 4 * j++)) & 15).toString(16);
+  }
+  return s;
+}

package/node/generateLicense/generateLicense.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateLicense = generateLicense;
+var _md = require("../encoding/md5");
+var _base = require("../encoding/base64");
+var _licenseScope = require("../utils/licenseScope");
+var _licensingModel = require("../utils/licensingModel");
+const licenseVersion = '2';
+function getClearLicenseString(details) {
+  if (details.scope && !_licenseScope.LICENSE_SCOPES.includes(details.scope)) {
+    throw new Error('MUI X: Invalid scope');
+  }
+  if (details.licensingModel && !_licensingModel.LICENSING_MODELS.includes(details.licensingModel)) {
+    throw new Error('MUI X: Invalid licensing model');
+  }
+  return `O=${details.orderNumber},E=${details.expiryDate.getTime()},S=${details.scope},LM=${details.licensingModel},KV=${licenseVersion}`;
+}
+function generateLicense(details) {
+  const licenseStr = getClearLicenseString(details);
+  return `${(0, _md.md5)((0, _base.base64Encode)(licenseStr))}${(0, _base.base64Encode)(licenseStr)}`;
+}

package/node/generateLicense/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _generateLicense = require("./generateLicense");
+Object.keys(_generateLicense).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _generateLicense[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generateLicense[key];
+    }
+  });
+});

package/node/index.js

@@ -0,0 +1,78 @@
+/**
+ * @mui/x-license v7.0.0-beta.2
+ *
+ * @license MUI X Commercial
+ * This source code is licensed under the commercial license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _generateLicense = require("./generateLicense");
+Object.keys(_generateLicense).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _generateLicense[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generateLicense[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _verifyLicense = require("./verifyLicense");
+Object.keys(_verifyLicense).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _verifyLicense[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _verifyLicense[key];
+    }
+  });
+});
+var _useLicenseVerifier = require("./useLicenseVerifier");
+Object.keys(_useLicenseVerifier).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useLicenseVerifier[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useLicenseVerifier[key];
+    }
+  });
+});
+var _Watermark = require("./Watermark");
+Object.keys(_Watermark).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Watermark[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Watermark[key];
+    }
+  });
+});
+var _Unstable_LicenseInfoProvider = require("./Unstable_LicenseInfoProvider");
+Object.keys(_Unstable_LicenseInfoProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Unstable_LicenseInfoProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Unstable_LicenseInfoProvider[key];
+    }
+  });
+});

package/node/useLicenseVerifier/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useLicenseVerifier", {
+  enumerable: true,
+  get: function () {
+    return _useLicenseVerifier.useLicenseVerifier;
+  }
+});
+var _useLicenseVerifier = require("./useLicenseVerifier");

package/node/useLicenseVerifier/useLicenseVerifier.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sharedLicenseStatuses = void 0;
+exports.useLicenseVerifier = useLicenseVerifier;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _verifyLicense = require("../verifyLicense/verifyLicense");
+var _licenseInfo = require("../utils/licenseInfo");
+var _licenseErrorMessageUtils = require("../utils/licenseErrorMessageUtils");
+var _licenseStatus = require("../utils/licenseStatus");
+var _LicenseInfoContext = _interopRequireDefault(require("../Unstable_LicenseInfoProvider/LicenseInfoContext"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const sharedLicenseStatuses = exports.sharedLicenseStatuses = {};
+function useLicenseVerifier(packageName, releaseInfo) {
+  const {
+    key: contextKey
+  } = React.useContext(_LicenseInfoContext.default);
+  return React.useMemo(() => {
+    const licenseKey = contextKey ?? _licenseInfo.LicenseInfo.getLicenseKey();
+
+    // Cache the response to not trigger the error twice.
+    if (sharedLicenseStatuses[packageName] && sharedLicenseStatuses[packageName].key === licenseKey) {
+      return sharedLicenseStatuses[packageName].licenseVerifier;
+    }
+    const acceptedScopes = packageName.includes('premium') ? ['premium'] : ['pro', 'premium'];
+    const plan = packageName.includes('premium') ? 'Premium' : 'Pro';
+    const licenseStatus = (0, _verifyLicense.verifyLicense)({
+      releaseInfo,
+      licenseKey,
+      acceptedScopes
+    });
+    const fullPackageName = `@mui/${packageName}`;
+    if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.Valid) {
+      // Skip
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.Invalid) {
+      (0, _licenseErrorMessageUtils.showInvalidLicenseKeyError)();
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.OutOfScope) {
+      (0, _licenseErrorMessageUtils.showLicenseKeyPlanMismatchError)();
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.NotFound) {
+      (0, _licenseErrorMessageUtils.showMissingLicenseKeyError)({
+        plan,
+        packageName: fullPackageName
+      });
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.ExpiredAnnualGrace) {
+      (0, _licenseErrorMessageUtils.showExpiredAnnualGraceLicenseKeyError)((0, _extends2.default)({
+        plan
+      }, licenseStatus.meta));
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.ExpiredAnnual) {
+      (0, _licenseErrorMessageUtils.showExpiredAnnualLicenseKeyError)((0, _extends2.default)({
+        plan
+      }, licenseStatus.meta));
+    } else if (licenseStatus.status === _licenseStatus.LICENSE_STATUS.ExpiredVersion) {
+      (0, _licenseErrorMessageUtils.showExpiredPackageVersionError)({
+        packageName: fullPackageName
+      });
+    } else if (process.env.NODE_ENV !== 'production') {
+      throw new Error('missing status handler');
+    }
+    sharedLicenseStatuses[packageName] = {
+      key: licenseKey,
+      licenseVerifier: licenseStatus
+    };
+    return licenseStatus;
+  }, [packageName, releaseInfo, contextKey]);
+}

package/node/utils/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _licenseErrorMessageUtils = require("./licenseErrorMessageUtils");
+Object.keys(_licenseErrorMessageUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _licenseErrorMessageUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _licenseErrorMessageUtils[key];
+    }
+  });
+});
+var _licenseInfo = require("./licenseInfo");
+Object.keys(_licenseInfo).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _licenseInfo[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _licenseInfo[key];
+    }
+  });
+});
+var _licenseStatus = require("./licenseStatus");
+Object.keys(_licenseStatus).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _licenseStatus[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _licenseStatus[key];
+    }
+  });
+});