@ianua/ianus-dataverse-react-fluentui8 1.0.5

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import * as React from 'react';
+
+interface IMeta {
+    name: string;
+}
+interface IEnvironmentIdentifier {
+    type: string;
+    identifier: string;
+    name: string;
+}
+interface ILicenseClaims {
+    jti: string;
+    iss: string;
+    aud: string;
+    pub: string;
+    prd: string;
+    sub: string;
+    env: IEnvironmentIdentifier[];
+    required_roles: string[];
+    iat: number;
+    nbf: number;
+    exp?: number;
+    custom: Record<string, any>;
+    iss_meta: IMeta;
+    aud_meta: IMeta;
+    pub_meta: IMeta;
+    prd_meta: IMeta;
+    sub_meta: IMeta;
+    env_meta: Record<string, IMeta>;
+    ver: string;
+}
+
+type DataverseLicenseValidationError = {
+    isValid: false;
+    reason: string;
+    isTerminalError?: boolean;
+    licenseId?: string;
+    licenseKey?: string;
+};
+type DataverseLicenseValidationSuccess = {
+    isValid: true;
+    claims: ILicenseClaims;
+    licenseId: string;
+    licenseKey: string;
+};
+type DataverseLicenseValidationResult = DataverseLicenseValidationError | DataverseLicenseValidationSuccess;
+
+type LicenseValidationError = {
+    isValid: false;
+    reason: string;
+    isTerminalError?: boolean;
+};
+type LicenseValidationSuccess = {
+    isValid: true;
+    claims: ILicenseClaims;
+};
+type LicenseValidationResult = LicenseValidationError | LicenseValidationSuccess;
+
+interface IIanusGuardProps {
+    publisherId: string;
+    productId: string;
+    publicKeys: string[];
+    environmentType: string;
+    environmentIdentifier: string | ComponentFramework.WebApi;
+    dataProvider: ComponentFramework.WebApi | ComponentFramework.PropertyTypes.DataSet;
+    onLicenseValidated?: (result: LicenseValidationResult) => unknown;
+}
+declare const isWebApi: (dataProvider: ComponentFramework.WebApi | ComponentFramework.PropertyTypes.DataSet | string) => dataProvider is ComponentFramework.WebApi;
+declare const isDataset: (dataProvider: ComponentFramework.WebApi | ComponentFramework.PropertyTypes.DataSet | string) => dataProvider is ComponentFramework.PropertyTypes.DataSet;
+declare const acquireLicenses: (publisherId: string, productId: string, dataProvider: ComponentFramework.WebApi | ComponentFramework.PropertyTypes.DataSet) => Promise<ComponentFramework.WebApi.Entity[]>;
+declare const IanusGuard: React.FC<IIanusGuardProps>;
+
+type Action = {
+    type: "setLicense";
+    payload: DataverseLicenseValidationResult | undefined;
+} | {
+    type: "setLicenseDialogVisible";
+    payload: boolean;
+};
+type IanusLicenseStateProps = {
+    license?: DataverseLicenseValidationResult;
+    licenseDialogVisible?: boolean;
+};
+type IanusLicenseDispatch = (action: Action) => void;
+declare const IanusLicenseDispatch: React.Context<IanusLicenseDispatch | undefined>;
+declare const IanusLicenseStateProvider: React.FC<IanusLicenseStateProps>;
+declare const useLicenseState: () => IanusLicenseStateProps;
+declare const useLicenseDispatch: () => IanusLicenseDispatch;
+declare const useLicenseContext: () => [IanusLicenseStateProps, IanusLicenseDispatch];
+
+interface IIanusProviderProps extends IIanusGuardProps {
+}
+declare const IanusProvider: React.FC<React.PropsWithChildren<IIanusProviderProps>>;
+
+interface ILicenseDialogProps {
+    publisherId: string;
+    productId: string;
+    dataProvider: ComponentFramework.WebApi | ComponentFramework.PropertyTypes.DataSet;
+    onSubmit: () => void;
+    onCancel: () => void;
+}
+declare const LicenseDialog: React.FC<ILicenseDialogProps>;
+
+declare const removeCurlyBrackets: (input: string | undefined | null) => string | undefined;
+
+declare const base64url_decode: (value: string) => ArrayBuffer;
+declare const validateLicense: (publisherId: string, productId: string, environmentType: string, environmentIdentifier: string, publicKeys: string[], licenseKey: string | undefined) => Promise<LicenseValidationResult>;
+
+export { type DataverseLicenseValidationError, type DataverseLicenseValidationResult, type DataverseLicenseValidationSuccess, type IEnvironmentIdentifier, type IIanusGuardProps, type IIanusProviderProps, type ILicenseClaims, type ILicenseDialogProps, type IMeta, IanusGuard, IanusLicenseDispatch, type IanusLicenseStateProps, IanusLicenseStateProvider, IanusProvider, LicenseDialog, type LicenseValidationError, type LicenseValidationResult, type LicenseValidationSuccess, acquireLicenses, base64url_decode, isDataset, isWebApi, removeCurlyBrackets, useLicenseContext, useLicenseDispatch, useLicenseState, validateLicense };

package/dist/index.js

@@ -0,0 +1,557 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  IanusGuard: () => IanusGuard,
+  IanusLicenseStateProvider: () => IanusLicenseStateProvider,
+  IanusProvider: () => IanusProvider,
+  LicenseDialog: () => LicenseDialog,
+  acquireLicenses: () => acquireLicenses,
+  base64url_decode: () => base64url_decode,
+  isDataset: () => isDataset,
+  isWebApi: () => isWebApi,
+  removeCurlyBrackets: () => removeCurlyBrackets,
+  useLicenseContext: () => useLicenseContext,
+  useLicenseDispatch: () => useLicenseDispatch,
+  useLicenseState: () => useLicenseState,
+  validateLicense: () => validateLicense
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/IanusGuard.tsx
+var React3 = __toESM(require("react"));
+var import_MessageBar = require("@fluentui/react/lib/MessageBar");
+var import_Button = require("@fluentui/react/lib/Button");
+var import_Spinner = require("@fluentui/react/lib/Spinner");
+
+// ../../../../ianus-core/LicenseValidation.ts
+var str2ab = (str) => {
+  const buf = new ArrayBuffer(str.length);
+  const bufView = new Uint8Array(buf);
+  for (let i = 0, strLen = str.length; i < strLen; i++) {
+    bufView[i] = str.charCodeAt(i);
+  }
+  return buf;
+};
+var importRsaKey = (pem) => {
+  const binaryDerString = window.atob(pem.replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "").trim());
+  const binaryDer = str2ab(binaryDerString);
+  return window.crypto.subtle.importKey(
+    "spki",
+    binaryDer,
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: "SHA-256"
+    },
+    true,
+    ["verify"]
+  );
+};
+var validateClaims = (publisherId, productId, environmentType, environmentIdentifier, license) => {
+  if (!license) {
+    return [false, "No license passed!"];
+  }
+  if (!license.env || !license.env.length || !license.aud || !license.iss) {
+    return [false, "Incomplete license!"];
+  }
+  const validIssuer = `https://www.ianusguard.com/api/public/products/${productId}`;
+  if (license.iss.toLowerCase() !== validIssuer.toLowerCase()) {
+    return [false, `Invalid license issuer: Issuer must be '${validIssuer}'`];
+  }
+  const validAudience = "ianusguard";
+  if (license.aud !== validAudience) {
+    return [false, `Invalid license audience: Audience must be '${publisherId}'`];
+  }
+  if (license.pub !== publisherId) {
+    return [false, `Invalid license publisher: Publisher must be '${publisherId}'`];
+  }
+  if (license.prd !== productId) {
+    return [false, `Invalid license product: Product must be '${productId}'`];
+  }
+  const formattedEnvironmentIdentifier = environmentIdentifier.replace("{", "").replace("}", "").toLowerCase();
+  if (!license.env.some((e) => e.type.toLowerCase() === environmentType && e.identifier.toLowerCase() == formattedEnvironmentIdentifier)) {
+    return [false, `Invalid organization: Your license is not intended for usage in environment of type '${environmentType}' and identifier '${formattedEnvironmentIdentifier}' but for '${JSON.stringify(license.env)}'`];
+  }
+  if (license.exp != null) {
+    if (isNaN(license.exp)) {
+      return [false, "Invalid license expiry: Expiry is not a number"];
+    }
+    const expiryDate = new Date(license.exp * 1e3);
+    if (expiryDate < /* @__PURE__ */ new Date()) {
+      return [false, `Invalid license expiry: License expired on '${expiryDate}'`];
+    }
+  }
+  return [true, ""];
+};
+var base64url_decode = (value) => {
+  const m = value.length % 4;
+  return Uint8Array.from(atob(
+    value.replace(/-/g, "+").replace(/_/g, "/").padEnd(value.length + (m === 0 ? 0 : 4 - m), "=")
+  ), (c) => c.charCodeAt(0)).buffer;
+};
+var verifySignature = (key, dataToVerify, signature) => __async(void 0, null, function* () {
+  return yield window.crypto.subtle.verify(
+    "RSASSA-PKCS1-v1_5",
+    key,
+    signature,
+    dataToVerify
+  );
+});
+var validateLicense = (publisherId, productId, environmentType, environmentIdentifier, publicKeys, licenseKey) => __async(void 0, null, function* () {
+  if (!licenseKey) {
+    return {
+      isValid: false,
+      isTerminalError: false,
+      reason: "No license key set!"
+    };
+  }
+  try {
+    const parts = licenseKey.split(".");
+    if (parts.length < 3) {
+      return {
+        isValid: false,
+        isTerminalError: false,
+        reason: "Incorrect license!"
+      };
+    }
+    const [encodedHeaders, encodedClaims, signature] = parts;
+    const plainClaims = new TextDecoder("utf-8").decode(base64url_decode(encodedClaims));
+    const claimsJson = JSON.parse(plainClaims);
+    const [claimsValidationResult, claimsValidationResultMessage] = validateClaims(publisherId, productId, environmentType, environmentIdentifier, claimsJson);
+    if (!claimsValidationResult) {
+      return {
+        isValid: false,
+        isTerminalError: false,
+        reason: claimsValidationResultMessage
+      };
+    }
+    const dataToVerify = new TextEncoder().encode(encodedHeaders + "." + encodedClaims);
+    const signatureToVerify = base64url_decode(signature);
+    for (const publicKey of publicKeys) {
+      if (publicKey) {
+        let keyImportSuccess = false;
+        try {
+          const key = yield importRsaKey(publicKey);
+          keyImportSuccess = true;
+          const isLicenseSignatureValid = yield verifySignature(key, dataToVerify, signatureToVerify);
+          if (isLicenseSignatureValid === true) {
+            return {
+              isValid: true,
+              claims: claimsJson
+            };
+          }
+        } catch (e) {
+          return {
+            isValid: false,
+            isTerminalError: false,
+            reason: keyImportSuccess ? "An error occured while verifying your license's signature" : "An error occured while importing your public key"
+          };
+        }
+      }
+    }
+    return {
+      isValid: false,
+      isTerminalError: false,
+      reason: "Invalid license signature: Verification failed!"
+    };
+  } catch (e) {
+    return {
+      isValid: false,
+      isTerminalError: true,
+      reason: "Oops, something went wrong while validating your license"
+    };
+  }
+});
+
+// src/LicenseDialog.tsx
+var React2 = __toESM(require("react"));
+var import_react = require("@fluentui/react");
+
+// src/IanusLicenseStateProvider.tsx
+var React = __toESM(require("react"));
+function stateReducer(state, action) {
+  switch (action.type) {
+    case "setLicense": {
+      return __spreadProps(__spreadValues({}, state), { license: action.payload });
+    }
+    case "setLicenseDialogVisible": {
+      return __spreadProps(__spreadValues({}, state), { licenseDialogVisible: action.payload });
+    }
+  }
+}
+var IanusLicenseState = React.createContext(void 0);
+var IanusLicenseDispatch = React.createContext(void 0);
+var IanusLicenseStateProvider = (props) => {
+  const [state, dispatch] = React.useReducer(stateReducer, props != null ? props : {});
+  return /* @__PURE__ */ React.createElement(IanusLicenseState.Provider, { value: state }, /* @__PURE__ */ React.createElement(IanusLicenseDispatch.Provider, { value: dispatch }, props.children));
+};
+var useLicenseState = () => {
+  const context = React.useContext(IanusLicenseState);
+  if (!context) {
+    throw new Error("useLicenseState must be used within a state provider!");
+  }
+  return context;
+};
+var useLicenseDispatch = () => {
+  const context = React.useContext(IanusLicenseDispatch);
+  if (!context) {
+    throw new Error("useLicenseDispatch must be used within a state provider!");
+  }
+  return context;
+};
+var useLicenseContext = () => {
+  return [useLicenseState(), useLicenseDispatch()];
+};
+
+// src/LicenseDialog.tsx
+var modalProps = {
+  isBlocking: false,
+  styles: { main: { maxWidth: 600 } }
+};
+var dialogContentProps = {
+  type: import_react.DialogType.largeHeader,
+  title: "License"
+};
+var LicenseDialog = ({ publisherId, productId, dataProvider, onCancel, onSubmit }) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+  const [licenseState, licenseDispatch] = useLicenseContext();
+  const [submitBlocked, setSubmitBlocked] = React2.useState(true);
+  const [licenseKeyInput, setLicenseKeyInput] = React2.useState((_a = licenseState.license) == null ? void 0 : _a.licenseKey);
+  const [licenseId, setLicenseId] = React2.useState((_b = licenseState == null ? void 0 : licenseState.license) == null ? void 0 : _b.licenseId);
+  const [error, setError] = React2.useState("");
+  React2.useEffect(() => {
+    (() => __async(void 0, null, function* () {
+      if (!licenseId) {
+        const licenses = yield acquireLicenses(publisherId, productId, dataProvider);
+        if (licenses.length > 0) {
+          setLicenseId(licenses[0].ian_licenseid);
+        }
+      }
+    }))();
+  }, []);
+  const tryToExtractDisplayNames = (licenseKey) => {
+    var _a2, _b2;
+    if (!licenseKey) {
+      return null;
+    }
+    const split = licenseKey.split(".");
+    if (split.length != 3) {
+      return null;
+    }
+    const body = split[1];
+    try {
+      const plainClaims = new TextDecoder("utf-8").decode(base64url_decode(body));
+      const claimsJson = JSON.parse(plainClaims);
+      if (((_a2 = claimsJson == null ? void 0 : claimsJson.pub_meta) == null ? void 0 : _a2.name) && ((_b2 = claimsJson.prd_meta) == null ? void 0 : _b2.name)) {
+        return {
+          publisher: claimsJson.pub_meta.name,
+          product: claimsJson.prd_meta.name
+        };
+      } else {
+        return null;
+      }
+    } catch (e) {
+      return null;
+    }
+  };
+  const onSubmitClick = () => __async(void 0, null, function* () {
+    var _a2, _b2;
+    try {
+      setSubmitBlocked(true);
+      const displayNames = tryToExtractDisplayNames(licenseKeyInput);
+      const name = `${(_a2 = displayNames == null ? void 0 : displayNames.publisher) != null ? _a2 : publisherId} - ${(_b2 = displayNames == null ? void 0 : displayNames.product) != null ? _b2 : productId}`;
+      const identifier = `${publisherId}_${productId}`;
+      if (licenseId) {
+        if (isWebApi(dataProvider)) {
+          yield dataProvider.updateRecord(
+            "ian_license",
+            licenseId,
+            {
+              "ian_name": name,
+              "ian_key": licenseKeyInput
+            }
+          );
+        } else if (isDataset(dataProvider)) {
+          yield dataProvider.records[licenseId].setValue("ian_name", name);
+          yield dataProvider.records[licenseId].setValue("ian_key", licenseKeyInput);
+          yield dataProvider.records[licenseId].save();
+        }
+      } else {
+        if (isWebApi(dataProvider)) {
+          yield dataProvider.createRecord(
+            "ian_license",
+            {
+              "ian_name": name,
+              "ian_identifier": identifier,
+              "ian_key": licenseKeyInput
+            }
+          );
+        } else if (isDataset(dataProvider)) {
+          const newLicense = yield dataProvider.newRecord();
+          yield newLicense.setValue("ian_name", name);
+          yield newLicense.setValue("ian_identifier", identifier);
+          yield newLicense.setValue("ian_key", licenseKeyInput);
+          yield newLicense.save();
+        }
+      }
+      onSubmit();
+    } catch (e) {
+      setError(e == null ? void 0 : e.message);
+    } finally {
+      setSubmitBlocked(false);
+    }
+  });
+  return /* @__PURE__ */ React2.createElement(
+    import_react.Dialog,
+    {
+      hidden: !(licenseState == null ? void 0 : licenseState.licenseDialogVisible),
+      onDismiss: onCancel,
+      dialogContentProps,
+      modalProps
+    },
+    error && /* @__PURE__ */ React2.createElement(
+      import_react.MessageBar,
+      {
+        messageBarType: import_react.MessageBarType.error,
+        isMultiline: true,
+        styles: { root: { marginBottom: "10px" } },
+        onDismiss: () => {
+          setError("");
+        }
+      },
+      "An error occured, please try again. Error information: ",
+      error
+    ),
+    /* @__PURE__ */ React2.createElement(import_react.TextField, { label: "License Key", value: licenseKeyInput, onChange: (e, v) => {
+      setLicenseKeyInput(v != null ? v : "");
+      setSubmitBlocked(false);
+    }, required: true }),
+    !!((_c = licenseState.license) == null ? void 0 : _c.isValid) && /* @__PURE__ */ React2.createElement(import_react.Text, null, /* @__PURE__ */ React2.createElement("br", null), /* @__PURE__ */ React2.createElement("h3", null, "License Information"), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement("span", { style: { fontWeight: "bold" } }, "License Publisher: "), " ", /* @__PURE__ */ React2.createElement("span", { title: (_e = (_d = licenseState.license) == null ? void 0 : _d.claims) == null ? void 0 : _e.pub }, (_h = (_g = (_f = licenseState.license) == null ? void 0 : _f.claims) == null ? void 0 : _g.pub_meta) == null ? void 0 : _h.name)), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement("span", { style: { fontWeight: "bold" } }, "Licensed Product: "), " ", /* @__PURE__ */ React2.createElement("span", { title: (_i = licenseState.license) == null ? void 0 : _i.claims.aud }, (_l = (_k = (_j = licenseState.license) == null ? void 0 : _j.claims) == null ? void 0 : _k.prd_meta) == null ? void 0 : _l.name)), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement("span", { style: { fontWeight: "bold" } }, "Licensed Customer: "), " ", /* @__PURE__ */ React2.createElement("span", { title: (_m = licenseState.license) == null ? void 0 : _m.claims.sub }, (_p = (_o = (_n = licenseState.license) == null ? void 0 : _n.claims) == null ? void 0 : _o.sub_meta) == null ? void 0 : _p.name)), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement("span", { style: { fontWeight: "bold" } }, "Licensed Dataverse Environment: "), " ", /* @__PURE__ */ React2.createElement("span", null, (_s = (_r = (_q = licenseState.license) == null ? void 0 : _q.claims) == null ? void 0 : _r.env) == null ? void 0 : _s.map((e) => `${e.identifier} (${e.name})`).join(", "))), /* @__PURE__ */ React2.createElement("p", null, /* @__PURE__ */ React2.createElement("span", { style: { fontWeight: "bold" } }, "License expires after: "), " ", /* @__PURE__ */ React2.createElement("span", null, !((_u = (_t = licenseState.license) == null ? void 0 : _t.claims) == null ? void 0 : _u.exp) ? "Never" : new Date(((_v = licenseState.license) == null ? void 0 : _v.claims.exp) * 1e3).toISOString()))),
+    /* @__PURE__ */ React2.createElement(import_react.DialogFooter, null, /* @__PURE__ */ React2.createElement(import_react.PrimaryButton, { onClick: onSubmitClick, text: "Submit", disabled: !licenseKeyInput || submitBlocked }), /* @__PURE__ */ React2.createElement(import_react.DefaultButton, { onClick: onCancel, text: "Cancel" }))
+  );
+};
+
+// src/IanusGuard.tsx
+var isWebApi = (dataProvider) => {
+  return dataProvider.retrieveMultipleRecords !== void 0;
+};
+var isDataset = (dataProvider) => {
+  return dataProvider.records !== void 0;
+};
+var acquireLicenses = (publisherId, productId, dataProvider) => __async(void 0, null, function* () {
+  const licenseIdentifier = `${publisherId}_${productId}`;
+  if (isWebApi(dataProvider)) {
+    const response = yield dataProvider.retrieveMultipleRecords("ian_license", `?$filter=ian_identifier eq '${licenseIdentifier}' and statecode eq 0`);
+    return response.entities;
+  } else if (isDataset(dataProvider)) {
+    if (dataProvider.records.length) {
+      const record = dataProvider.records[0];
+      if (record.getNamedReference().etn !== "ian_license") {
+        throw new Error("You need to pass the 'ian_license' entity as data source for LicenseDataset when using a dataset as value");
+      }
+    }
+    return Object.values(dataProvider.records).filter((r) => r.getValue("ian_identifier") === licenseIdentifier).map((r) => dataProvider.columns.reduce((all, cur) => __spreadProps(__spreadValues({}, all), { [cur.name]: r.getValue(cur.name) }), { ian_licenseid: r.getRecordId() }));
+  } else {
+    throw new Error(`The 'dataProvider' prop must be either of type ComponentFramework.WebApi or ComponentFramework.PropertyTypes.Dataset. You passed '${typeof dataProvider}'.`);
+  }
+});
+var updateResultIfDefined = (result, onLicenseValidated) => {
+  if (onLicenseValidated) {
+    try {
+      onLicenseValidated(result);
+    } catch (e) {
+      if (e && e instanceof Error) {
+        console.error(`Error while calling onLicenseValidated: '${e.message}'`);
+      }
+    }
+  }
+};
+var fetchOrganizationIdFromWebApi = (webApi) => __async(void 0, null, function* () {
+  const results = yield webApi.retrieveMultipleRecords("organization", "?$top=1&$select=organizationid");
+  if (!results.entities.length) {
+    return null;
+  }
+  const organization = results.entities[0];
+  return organization.organizationid;
+});
+var IanusGuard = ({ publisherId, productId, publicKeys, environmentType, environmentIdentifier, dataProvider, onLicenseValidated, children }) => {
+  var _a, _b, _c, _d;
+  const [licenseState, licenseDispatch] = useLicenseContext();
+  const onSettingsFinally = () => {
+    licenseDispatch({ type: "setLicenseDialogVisible", payload: false });
+    initLicenseValidation();
+  };
+  const runValidation = () => __async(void 0, null, function* () {
+    try {
+      if (!productId) {
+        return {
+          isValid: false,
+          isTerminalError: true,
+          reason: "No productId found, pass a productId as prop!"
+        };
+      }
+      if (!publicKeys || !publicKeys.length) {
+        return {
+          isValid: false,
+          isTerminalError: true,
+          reason: "No public key found, pass a valid public key as prop!"
+        };
+      }
+      const licenses = yield acquireLicenses(publisherId, productId, dataProvider);
+      if (!licenses.length) {
+        return {
+          isValid: false,
+          isTerminalError: false,
+          reason: "No license found!"
+        };
+      }
+      if (licenses.length > 1) {
+        return {
+          isValid: false,
+          isTerminalError: true,
+          reason: `Multiple active licenses for '${publisherId}_${productId}' found, please make sure there is only one active license`
+        };
+      }
+      const licenseRecord = licenses[0];
+      const resolvedEnvironmentIdentifier = isWebApi(environmentIdentifier) ? yield fetchOrganizationIdFromWebApi(environmentIdentifier) : environmentIdentifier;
+      const validationResult = yield validateLicense(publisherId, productId, environmentType, resolvedEnvironmentIdentifier, publicKeys, licenseRecord.ian_key);
+      return __spreadProps(__spreadValues({}, validationResult), {
+        licenseId: licenseRecord.ian_licenseid,
+        licenseKey: licenseRecord.ian_key
+      });
+    } catch (e) {
+      return {
+        isValid: false,
+        isTerminalError: true,
+        reason: e == null ? void 0 : e.message
+      };
+    }
+  });
+  const initLicenseValidation = () => __async(void 0, null, function* () {
+    const result = yield runValidation();
+    licenseDispatch({ type: "setLicense", payload: result });
+    updateResultIfDefined(result, onLicenseValidated);
+  });
+  React3.useEffect(() => {
+    if (!isDataset(dataProvider) || !dataProvider.error && !dataProvider.loading && dataProvider.paging.totalResultCount >= 0) {
+      initLicenseValidation();
+    } else if (dataProvider.error) {
+      const result = {
+        isValid: false,
+        isTerminalError: true,
+        reason: `Dataset error: ${dataProvider.errorMessage}`
+      };
+      updateResultIfDefined(result, onLicenseValidated);
+    }
+  }, [
+    isDataset(dataProvider) ? dataProvider.sortedRecordIds.length : dataProvider
+  ]);
+  return ((_a = licenseState.license) == null ? void 0 : _a.isValid) ? /* @__PURE__ */ React3.createElement(React3.Fragment, null, licenseState.licenseDialogVisible && /* @__PURE__ */ React3.createElement(LicenseDialog, { publisherId, productId, dataProvider, onSubmit: onSettingsFinally, onCancel: onSettingsFinally }), children) : /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", width: "100%", height: "100%", flex: "1" } }, licenseState.licenseDialogVisible && /* @__PURE__ */ React3.createElement(LicenseDialog, { publisherId, productId, dataProvider, onSubmit: onSettingsFinally, onCancel: onSettingsFinally }), /* @__PURE__ */ React3.createElement("div", { style: { display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center", flex: 1 } }, ((_b = licenseState.license) == null ? void 0 : _b.isValid) === false && /* @__PURE__ */ React3.createElement(
+    import_MessageBar.MessageBar,
+    {
+      messageBarType: import_MessageBar.MessageBarType.error,
+      isMultiline: true,
+      styles: { root: { marginBottom: "10px" } },
+      onDismiss: () => {
+        licenseDispatch({ type: "setLicense", payload: void 0 });
+        initLicenseValidation();
+      },
+      actions: /* @__PURE__ */ React3.createElement("div", null, !((_c = licenseState.license) == null ? void 0 : _c.isTerminalError) && /* @__PURE__ */ React3.createElement(import_Button.MessageBarButton, { onClick: () => licenseDispatch({ type: "setLicenseDialogVisible", payload: true }) }, "Set License"))
+    },
+    "An error occured, please try again. Error information: ",
+    (_d = licenseState.license) == null ? void 0 : _d.reason
+  ), !licenseState.license && /* @__PURE__ */ React3.createElement(import_Spinner.Spinner, { styles: { root: { width: "auto" } }, label: "Loading..." })));
+};
+
+// src/IanusProvider.tsx
+var React4 = __toESM(require("react"));
+var IanusProvider = (props) => {
+  return /* @__PURE__ */ React4.createElement(IanusLicenseStateProvider, null, /* @__PURE__ */ React4.createElement(IanusGuard, __spreadValues({}, props)));
+};
+
+// ../../../../ianus-core/GuidTools.ts
+var removeCurlyBrackets = (input) => {
+  var _a;
+  return (_a = input == null ? void 0 : input.replace("{", "")) == null ? void 0 : _a.replace("}", "");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IanusGuard,
+  IanusLicenseStateProvider,
+  IanusProvider,
+  LicenseDialog,
+  acquireLicenses,
+  base64url_decode,
+  isDataset,
+  isWebApi,
+  removeCurlyBrackets,
+  useLicenseContext,
+  useLicenseDispatch,
+  useLicenseState,
+  validateLicense
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ianua/ianus-dataverse-react-fluentui8",
+  "version": "1.0.5",
+  "description": "Client-side validation for Ianus Guard licenses in Dataverse using react and FluentUi v8",
+  "scripts": {
+    "build": "tsup"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "peerDependencies": {
+    "@fluentui/react": "^8",
+    "react": "^16.8 || ^17 || ^18",
+    "react-dom": "^16.8 || ^17 || ^18"
+  },
+  "dependencies": {
+    "@fluentui/react": "8.29.0",
+    "react": "^16.8 || ^17 || ^18",
+    "react-dom": "^16.8 || ^17 || ^18"
+  },
+  "devDependencies": {
+    "@microsoft/eslint-plugin-power-apps": "^0.2.33",
+    "@types/node": "^18.19.31",
+    "@types/powerapps-component-framework": "^1.3.11",
+    "@types/react": "^16.14.60",
+    "@types/react-dom": "^16.9.24",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/parser": "^7.7.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-react": "^7.34.1",
+    "pcf-scripts": "^1",
+    "pcf-start": "^1",
+    "react": "^16.14.0",
+    "tsup": "^8.3.5",
+    "typescript": "^4.9.5"
+  }
+}