@portnet/ui 5.0.12 → 5.0.14

package/dist/api/guideApi.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.guideApi = void 0;
+const guideApi = axiosInstance => ({
+  getGuideByProjectCode: projectCode => axiosInstance.get("/guide/".concat(projectCode)),
+  getGuideContent: projectCode => axiosInstance.get("/guide/".concat(projectCode, "/content")),
+  getFaqContent: () => axiosInstance.get("/guide/FAQ/content")
+});
+exports.guideApi = guideApi;

package/dist/api/guideImageService.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.guideImageService = exports.default = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.starts-with.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url.to-json.js");
+require("core-js/modules/web.url-search-params.js");
+class ImageCacheService {
+  constructor() {
+    this.cache = new Map();
+    this.loading = new Map();
+  }
+  getCacheKey(projectCode, imageOrder) {
+    return "".concat(projectCode, "-").concat(imageOrder);
+  }
+  has(projectCode, imageOrder) {
+    return this.cache.has(this.getCacheKey(projectCode, imageOrder));
+  }
+  get(projectCode, imageOrder) {
+    return this.cache.get(this.getCacheKey(projectCode, imageOrder));
+  }
+  set(projectCode, imageOrder, url) {
+    this.cache.set(this.getCacheKey(projectCode, imageOrder), url);
+  }
+  clear() {
+    this.cache.forEach(url => {
+      if (url.startsWith("blob:")) URL.revokeObjectURL(url);
+    });
+    this.cache.clear();
+    this.loading.clear();
+  }
+  delete(projectCode, imageOrder) {
+    const key = this.getCacheKey(projectCode, imageOrder);
+    const url = this.cache.get(key);
+    if (url !== null && url !== void 0 && url.startsWith("blob:")) URL.revokeObjectURL(url);
+    this.cache.delete(key);
+    this.loading.delete(key);
+  }
+}
+const imageCacheService = new ImageCacheService();
+const guideImageService = axiosInstance => ({
+  loadGuideImage: async (projectCode, imageOrder) => {
+    const key = imageCacheService.getCacheKey(projectCode, imageOrder);
+    if (imageCacheService.has(projectCode, imageOrder)) {
+      return imageCacheService.get(projectCode, imageOrder);
+    }
+    if (imageCacheService.loading.has(key)) {
+      return imageCacheService.loading.get(key);
+    }
+    const loadingPromise = (async () => {
+      try {
+        const response = await axiosInstance.get("/public/getImage/".concat(projectCode, "/").concat(imageOrder), {
+          responseType: "blob"
+        });
+        const imageUrl = URL.createObjectURL(response.data);
+        imageCacheService.set(projectCode, imageOrder, imageUrl);
+        imageCacheService.loading.delete(key);
+        return imageUrl;
+      } catch (error) {
+        imageCacheService.loading.delete(key);
+        throw error;
+      }
+    })();
+    imageCacheService.loading.set(key, loadingPromise);
+    return loadingPromise;
+  },
+  loadGuideImages: async (projectCode, imageOrders) => {
+    if (!imageOrders || imageOrders.length === 0) return {};
+    const promises = imageOrders.map(async imageOrder => {
+      try {
+        const url = await guideImageService(axiosInstance).loadGuideImage(projectCode, imageOrder);
+        return {
+          imageOrder,
+          url,
+          error: null
+        };
+      } catch (error) {
+        console.error("Failed to load image ".concat(projectCode, "/").concat(imageOrder, ":"), error);
+        return {
+          imageOrder,
+          url: null,
+          error: error.message
+        };
+      }
+    });
+    const results = await Promise.all(promises);
+    const imageMap = {};
+    results.forEach(_ref => {
+      let {
+        imageOrder,
+        url,
+        error
+      } = _ref;
+      imageMap[imageOrder] = {
+        url,
+        error
+      };
+    });
+    return imageMap;
+  },
+  preloadImages: (projectCode, imageOrders) => {
+    if (!imageOrders || imageOrders.length === 0) return;
+    imageOrders.forEach(imageOrder => {
+      guideImageService(axiosInstance).loadGuideImage(projectCode, imageOrder).catch(() => {});
+    });
+  },
+  clearImageCache: () => imageCacheService.clear(),
+  clearImage: (projectCode, imageOrder) => imageCacheService.delete(projectCode, imageOrder)
+});
+exports.guideImageService = guideImageService;
+var _default = exports.default = guideImageService;

package/dist/api/reclamationApi.js

@@ -0,0 +1,83 @@
+"use strict";
+
+require("core-js/modules/esnext.iterator.filter.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reclamationApi = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.string.search.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const reclamationApi = axiosInstance => ({
+  getListReclamationApi: async _ref => {
+    let {
+      page,
+      size,
+      search
+    } = _ref;
+    try {
+      const response = await axiosInstance.get("/reclamation/list", {
+        params: _objectSpread({
+          page,
+          size
+        }, search ? {
+          search
+        } : {})
+      });
+      return response.data.body;
+    } catch (error) {
+      var _error$response;
+      throw (error === null || error === void 0 || (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data) || new Error("Impossible de charger les réclamations");
+    }
+  },
+  createReclamationApi: async data => {
+    try {
+      const formData = new FormData();
+      const serviceConcerne = data.service.codigo;
+      formData.append("type", data.type);
+      formData.append("service", serviceConcerne);
+      formData.append("objet", data.objet);
+      formData.append("description", data.sujet);
+      if (data.files && data.files.length > 0) {
+        data.files.forEach(file => {
+          formData.append("files", file);
+        });
+      }
+      const response = await axiosInstance.post("/reclamation/create", formData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      return response.data.body;
+    } catch (error) {
+      var _error$response2;
+      throw (error === null || error === void 0 || (_error$response2 = error.response) === null || _error$response2 === void 0 ? void 0 : _error$response2.data) || new Error("Impossible de create nouvelle réclamation");
+    }
+  },
+  downloadDocumentApi: async documentGuid => {
+    try {
+      const response = await axiosInstance.post("/reclamation/download?guid=".concat(documentGuid));
+      return response.data.body;
+    } catch (error) {
+      var _error$response3;
+      throw (error === null || error === void 0 || (_error$response3 = error.response) === null || _error$response3 === void 0 ? void 0 : _error$response3.data) || new Error("Impossible de charger les réclamations");
+    }
+  },
+  getListServiceReclamationApi: async () => {
+    try {
+      const response = await axiosInstance.get("/reclamation/list-service");
+      return response.data.body;
+    } catch (error) {
+      var _error$response4;
+      throw (error === null || error === void 0 || (_error$response4 = error.response) === null || _error$response4 === void 0 ? void 0 : _error$response4.data) || new Error("Impossible de charger les réclamations");
+    }
+  }
+});
+exports.reclamationApi = reclamationApi;

package/dist/assets/guides/FAQ.json

@@ -0,0 +1,118 @@
+{
+  "id": "FAQ",
+  "name": "Liste des questions fréquentes et réponses sur PortNet",
+  "icon": "assignment",
+  "sections": [
+    {
+      "id": "MFA",
+      "title": "Introduction à Portnet ID et à l'Authentification Multifacteur (MFA)",
+      "paragraphs": [
+        { "text": "Qu'est-ce que Portnet ID ?", "isQuestion": true },
+        { "text": "Portnet ID est l'application mobile officielle de PORTNET S.A. pour l'authentification à deux facteurs (2FA) ou Multi-Factor Authentication (MFA). Elle est conçue pour sécuriser l'accès aux applications PortNet en générant des codes TOTP (Time-based One-Time Password). Cette application vise à renforcer la sécurité des accès, assurer une traçabilité fiable et simplifier la connexion à votre compte.", "isQuestion": false },
+        { "text": "Pourquoi l'authentification MFA via Portnet ID est-elle obligatoire ?", "isQuestion": true },
+        { "text": "L'authentification MFA via Portnet ID est obligatoire depuis le 21 juillet 2025. Elle répond aux directives de la DGSSI et permet de renforcer la sécurité des comptes PortNet face au contexte actuel de cyberattaques.", "isQuestion": false },
+        { "text": "Qu'est-ce qu'un code TOTP et comment fonctionne-t-il ?", "isQuestion": true },
+        { "text": "Un code TOTP est un code temporaire à usage unique généré toutes les 30 secondes par l’application Portnet ID. Basé sur l’heure, il est plus sécurisé qu’un OTP traditionnel.", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "INSTALL",
+      "title": "Installation et Première Utilisation de Portnet ID",
+      "paragraphs": [
+        { "text": "Comment installer l'application Portnet ID ?", "isQuestion": true },
+        { "text": "Pour installer l'application Portnet ID, ouvrez le Google Play Store (Android) ou l'App Store (iOS), recherchez 'PortnetID' (sans espace), puis appuyez sur 'Installer' ou 'Obtenir'. Accordez les permissions nécessaires, notamment l’accès à la caméra pour le scan du QR code.", "isQuestion": false },
+        { "text": "Comment configurer mon compte pour la première fois avec Portnet ID ?", "isQuestion": true },
+        { "text": "1. Accédez à portnet.ma et connectez-vous avec votre nom d’utilisateur et mot de passe.", "isQuestion": false },
+        { "text": "2. Un QR code s’affichera à l’écran.", "isQuestion": false },
+        { "text": "3. Ouvrez l’application Portnet ID sur votre mobile.", "isQuestion": false },
+        { "text": "4. Appuyez sur 'Ajouter un compte' ou sur '+', puis sur 'Scanner le QR code'.", "isQuestion": false },
+        { "text": "5. Scannez le QR code affiché sur votre ordinateur.", "isQuestion": false },
+        { "text": "6. L’application génère immédiatement un code TOTP à 6 chiffres.", "isQuestion": false },
+        { "text": "7. Saisissez ce code sur portnet.ma pour finaliser la connexion.", "isQuestion": false },
+        { "text": "Note : Vous pouvez aussi recevoir les codes TOTP par email après la configuration initiale.", "isQuestion": false },
+        { "text": "Puis-je gérer plusieurs comptes PortNet sur la même application Portnet ID ?", "isQuestion": true },
+        { "text": "Oui, Portnet ID permet la gestion multi-comptes. Appuyez sur '+', scannez les QR codes supplémentaires, puis renommez les comptes pour une meilleure organisation (ex : société 1, société 2…).", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "ACCOUNTS",
+      "title": "Gestion des Comptes Utilisateurs sur PortNet",
+      "paragraphs": [
+        { "text": "Plusieurs personnes peuvent-elles utiliser le même compte PortNet avec Portnet ID ?", "isQuestion": true },
+        { "text": "Non. L’authentification MFA est individuelle et liée au smartphone ayant scanné le QR code.", "isQuestion": false },
+        { "text": "Comment ajouter d'autres utilisateurs pour ma société sur PortNet ?", "isQuestion": true },
+        { "text": "Pour ajouter des utilisateurs, transmettez les documents via reclamation.portnet.ma :", "isQuestion": false },
+        { "text": "- Une demande d'accès signée et cachetée.", "isQuestion": false },
+        { "text": "- Une demande explicative sur papier en-tête précisant le profil.", "isQuestion": false },
+        { "text": "- Copie du RC (moins de 3 mois).", "isQuestion": false },
+        { "text": "- Copie de la CNI de chaque utilisateur.", "isQuestion": false },
+        { "text": "L’ajout d’utilisateurs est-il payant ?", "isQuestion": true },
+        { "text": "Non, la création d’utilisateurs est gratuite.", "isQuestion": false },
+        { "text": "Y a-t-il une limite au nombre d'utilisateurs ?", "isQuestion": true },
+        { "text": "Par défaut, jusqu’à 5 utilisateurs. Au-delà, la demande est étudiée au cas par cas.", "isQuestion": false },
+        { "text": "L'adresse email doit-elle être liée au nom de domaine de l'entreprise ?", "isQuestion": true },
+        { "text": "Il est fortement conseillé d'utiliser une adresse professionnelle. Si ce n’est pas le cas (ex : Gmail), une visio enregistrée sera exigée pour confirmer la demande.", "isQuestion": false },
+        { "text": "Que faire si un utilisateur ne fait plus partie de l'entreprise ?", "isQuestion": true },
+        { "text": "Vous devez demander la désactivation de son compte PortNet immédiatement.", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "PROCURA",
+      "title": "Gestion des Procurations (Délégations)",
+      "paragraphs": [
+        { "text": "Qu'est-ce que le service de Procuration sur PortNet ?", "isQuestion": true },
+        { "text": "Il permet aux importateurs/exportateurs d’attribuer des procurations à des transitaires, FF ou transporteurs afin de réaliser des formalités en leur nom.", "isQuestion": false },
+        { "text": "Comment attribuer une procuration ?", "isQuestion": true },
+        { "text": "Via le menu Paramétrage > Gestion des procurations, recherchez le transitaire, sélectionnez les profils concernés et validez. Le transitaire reçoit un email de confirmation.", "isQuestion": false },
+        { "text": "Quelles limitations peuvent être appliquées ?", "isQuestion": true },
+        { "text": "Vous pouvez définir une date limite ou un nombre maximum de dossiers.", "isQuestion": false },
+        { "text": "Comment sont gérées les limitations ?", "isQuestion": true },
+        { "text": "Le système indique si la procuration est expirée, et déduit le nombre de dossiers à mesure qu’ils sont traités.", "isQuestion": false },
+        { "text": "Quelles opérations peuvent être effectuées avec une procuration ?", "isQuestion": true },
+        { "text": "TI, LE, rendez-vous TCs import, préavis export, ANRT, DFD, COC, demandes d’instruments de mesure…", "isQuestion": false },
+        { "text": "Différence entre procuration PortNet et procuration Douane ?", "isQuestion": true },
+        { "text": "La procuration PortNet est interne au Guichet Unique. La procuration Douane est un document distinct soumis via PortNet et utilisé pour BADR.", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "TROUBLESHOOT",
+      "title": "Dépannage des Problèmes Courants",
+      "paragraphs": [
+        { "text": "Le QR code ne s'affiche pas.", "isQuestion": true },
+        { "text": "Cela signifie qu’il a déjà été scanné. Demandez une réinitialisation via reclamation.portnet.ma.", "isQuestion": false },
+        { "text": "Le code TOTP est invalide.", "isQuestion": true },
+        { "text": "- Vérifiez l’heure du téléphone (synchronisation automatique).", "isQuestion": false },
+        { "text": "- Attendez le prochain code (validité 30 secondes).", "isQuestion": false },
+        { "text": "- Réinstallez l’application si nécessaire.", "isQuestion": false },
+        { "text": "L'application ne se lance pas.", "isQuestion": true },
+        { "text": "Redémarrez le téléphone, videz le cache, libérez de l’espace, ou réinstallez l'application.", "isQuestion": false },
+        { "text": "Impossible de scanner un QR code.", "isQuestion": true },
+        { "text": "Vérifiez les permissions caméra, améliorez l’éclairage, ajustez la distance, nettoyez l’écran.", "isQuestion": false },
+        { "text": "Que faire en cas de perte ou vol du téléphone ?", "isQuestion": true },
+        { "text": "- Changez le mot de passe PortNet.", "isQuestion": false },
+        { "text": "- Demandez une réinitialisation du QR code.", "isQuestion": false },
+        { "text": "- Reconfigurez Portnet ID sur le nouveau téléphone.", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "SECURITY",
+      "title": "Sécurité et Bonnes Pratiques",
+      "paragraphs": [
+        { "text": "Activez un verrouillage d'écran sur votre smartphone et gardez-le à jour.", "isQuestion": false },
+        { "text": "Téléchargez l’application uniquement depuis les stores officiels.", "isQuestion": false },
+        { "text": "Ne partagez jamais vos codes TOTP et ne faites pas de captures d’écran.", "isQuestion": false },
+        { "text": "Utilisez les codes rapidement et assurez-vous que l’heure de votre téléphone est correcte.", "isQuestion": false }
+      ]
+    },
+    {
+      "id": "SUPPORT",
+      "title": "Support et Ressources",
+      "paragraphs": [
+        { "text": "Où obtenir de l'aide ?", "isQuestion": true },
+        { "text": "Via reclamation.portnet.ma ou par téléphone au 05 20 47 31 00.", "isQuestion": false },
+        { "text": "Où trouver les guides et documents utiles ?", "isQuestion": true },
+        { "text": "Les guides utilisateurs et documents sont disponibles sur le portail PortNet, dans le menu Assistance > Ressources > Guide utilisateur.", "isQuestion": false }
+      ]
+    }
+  ]
+}

package/dist/assets/guides/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _FAQ = _interopRequireDefault(require("./FAQ.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = {
+  "FAQ": _FAQ.default
+};

package/dist/components/common/PuiHelpWidgetContext.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHelpWidget = exports.default = void 0;
+var _react = require("react");
+const PuiHelpWidgetContext = /*#__PURE__*/(0, _react.createContext)(null);
+const useHelpWidget = () => {
+  const context = (0, _react.useContext)(PuiHelpWidgetContext);
+  if (!context) {
+    throw new Error("useHelpWidget must be used inside PuiHelpWidgetProvider");
+  }
+  return context;
+};
+exports.useHelpWidget = useHelpWidget;
+var _default = exports.default = PuiHelpWidgetContext;

package/dist/components/providers/PuiHelpWidgetProvider.js

@@ -0,0 +1,85 @@
+"use strict";
+
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.promise.js");
+var _react = _interopRequireWildcard(require("react"));
+var _axios = _interopRequireDefault(require("axios"));
+var _reactRedux = require("react-redux");
+var _toolkit = require("@reduxjs/toolkit");
+var _reactQuery = require("react-query");
+var _reclamationApi = require("../../api/reclamationApi");
+var _guideApi = require("../../api/guideApi");
+var _PuiHelpWidgetContext = _interopRequireDefault(require("../common/PuiHelpWidgetContext"));
+var _PuiHelpWidget = _interopRequireDefault(require("../widgets/PuiHelpWidget"));
+var _guideImageService = _interopRequireDefault(require("../../api/guideImageService"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const widgetStore = (0, _toolkit.configureStore)({
+  reducer: {}
+});
+const widgetQueryClient = new _reactQuery.QueryClient();
+const PuiHelpWidgetProvider = _ref => {
+  let {
+    baseURL,
+    tijariaUrl,
+    apiAuthUrl,
+    guideBaseUrl,
+    token,
+    showReclamation = true,
+    showGuides = true,
+    currentProjectCode = null,
+    children
+  } = _ref;
+  const axiosInstance = (0, _react.useMemo)(() => {
+    const instance = _axios.default.create({
+      baseURL
+    });
+    instance.interceptors.request.use(config => {
+      config.headers.Authorization = "Bearer ".concat(token);
+      return config;
+    });
+    instance.interceptors.response.use(res => res, err => {
+      var _err$response;
+      if (((_err$response = err.response) === null || _err$response === void 0 ? void 0 : _err$response.status) === 401) {
+        console.error("Session expired");
+      }
+      return Promise.reject(err);
+    });
+    return instance;
+  }, [baseURL, token]);
+  const publicAxiosInstance = (0, _react.useMemo)(() => {
+    return _axios.default.create({
+      baseURL
+    });
+  }, [baseURL]);
+  const value = {
+    reclamationApi: (0, _reclamationApi.reclamationApi)(axiosInstance),
+    guideApi: (0, _guideApi.guideApi)(axiosInstance),
+    guideImageService: (0, _guideImageService.default)(publicAxiosInstance),
+    tijariaUrl,
+    apiAuthUrl,
+    token
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactRedux.Provider, {
+    store: widgetStore,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactQuery.QueryClientProvider, {
+      client: widgetQueryClient,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_PuiHelpWidgetContext.default.Provider, {
+        value: value,
+        children: [children, /*#__PURE__*/(0, _jsxRuntime.jsx)(_PuiHelpWidget.default, {
+          showReclamation: showReclamation,
+          showGuides: showGuides,
+          currentProjectCode: currentProjectCode,
+          guideBaseUrl: guideBaseUrl
+        })]
+      })
+    })
+  });
+};
+var _default = exports.default = PuiHelpWidgetProvider;