@lv-x-software-house/x_view 1.2.6-dev.2 → 1.2.6-dev.21

package/dist/server.mjs

@@ -0,0 +1,445 @@
+// src/x_view_server_logic.js
+async function save_view_data_logic(db_services, filename, data) {
+  try {
+    const saveResult = await db_services.save_file(filename, data);
+    return saveResult;
+  } catch (error) {
+    console.error("catch (error) em save_view_data_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function get_scene_view_data_logic(db_services, scene_config, owner_id, type, session, focusNodeId = null, focusAncestryId = null) {
+  var _a, _b;
+  try {
+    if (!session || !session.user) {
+      return { success: false, error: "Usu\xE1rio n\xE3o autenticado." };
+    }
+    const membershipCheck = await db_services.check_membership(owner_id, type, scene_config, session.user.id);
+    const isFullMember = membershipCheck.success && membershipCheck.isValidMember;
+    if (!isFullMember && !focusNodeId && !focusAncestryId) {
+      return { success: false, error: "Acesso Negado: Voc\xEA n\xE3o possui permiss\xE3o para acessar este cen\xE1rio." };
+    }
+    const sceneResponse = await db_services.get_file(`x_view_scenes/${owner_id}/${scene_config}`);
+    if (!sceneResponse || !sceneResponse.success) {
+      console.error("Falha ao buscar dados da cena:", sceneResponse == null ? void 0 : sceneResponse.error);
+      return { success: false, error: `N\xE3o foi poss\xEDvel carregar o arquivo da cena: ${scene_config}` };
+    }
+    const sceneData = sceneResponse.data;
+    const parentDbObjects = sceneData.parent_dbs || [];
+    if (type && type.toLowerCase().includes("database")) {
+      const selfExists = parentDbObjects.some((db) => String(db.db_id) === String(scene_config));
+      if (!selfExists) {
+        parentDbObjects.push({ db_id: scene_config, owner_id });
+      }
+    }
+    const parentResponsesPromises = parentDbObjects.map(
+      (db_info) => db_services.get_file(`x_view_dbs/${db_info.owner_id}/${db_info.db_id}`)
+    );
+    const parentResponsesResults = await Promise.allSettled(parentResponsesPromises);
+    const parentData = {};
+    for (let i = 0; i < parentResponsesResults.length; i++) {
+      const result = parentResponsesResults[i];
+      const db_info = parentDbObjects[i];
+      if (result.status === "fulfilled" && ((_a = result.value) == null ? void 0 : _a.success)) {
+        parentData[db_info.db_id] = result.value.data;
+      } else {
+        console.warn(
+          `Arquivo pai n\xE3o carregado: ${db_info.db_id}. Pode ter sido deletado.`,
+          result.status === "rejected" ? result.reason : (_b = result.value) == null ? void 0 : _b.error
+        );
+      }
+    }
+    if (type && type.toLowerCase() === "view") {
+      parentData[scene_config] = {
+        dataset_name: "Quests Internas (View)",
+        nodes: sceneData.quest_nodes || [],
+        links: sceneData.quest_links || []
+      };
+    }
+    const allNodes = Object.values(parentData).flatMap((db) => db.nodes || []);
+    const allLinks = Object.values(parentData).flatMap((db) => db.links || []);
+    const parentNodeMap = new Map(allNodes.map((node) => [String(node.id), node]));
+    const parentLinkMap = new Map(allLinks.map((link) => [`${link.source}-${link.target}`, link]));
+    const validatedNodes = (sceneData.nodes || []).map((sceneNode) => {
+      var _a2, _b2;
+      const nodeTypes = Array.isArray(sceneNode.type) ? sceneNode.type : [sceneNode.type];
+      if (nodeTypes.includes("quest")) {
+        const dbQuestNode = (_b2 = (_a2 = parentData[scene_config]) == null ? void 0 : _a2.nodes) == null ? void 0 : _b2.find((qn) => String(qn.id) === String(sceneNode.id));
+        if (dbQuestNode) {
+          return { ...sceneNode, ...dbQuestNode };
+        }
+        return sceneNode;
+      }
+      const dbNode = parentNodeMap.get(String(sceneNode.id));
+      if (dbNode) {
+        return { ...sceneNode, ...dbNode };
+      }
+      return null;
+    }).filter(Boolean);
+    const validNodeIdsInScene = new Set(validatedNodes.map((node) => String(node.id)));
+    const validatedLinks = (sceneData.links || []).filter((sceneLink) => {
+      const linkExistsInParent = parentLinkMap.has(`${sceneLink.source}-${sceneLink.target}`);
+      const nodesAreValidForScene = validNodeIdsInScene.has(String(sceneLink.source)) && validNodeIdsInScene.has(String(sceneLink.target));
+      return linkExistsInParent && nodesAreValidForScene;
+    }).map((sceneLink) => parentLinkMap.get(`${sceneLink.source}-${sceneLink.target}`));
+    const validatedSceneData = {
+      ...sceneData,
+      nodes: validatedNodes,
+      links: validatedLinks
+    };
+    const ancestryFilePaths = [];
+    ancestryFilePaths.push({
+      path: `x_view_ancestry/${owner_id}/${scene_config}`,
+      source_id: scene_config,
+      owner_id,
+      isSceneFile: true
+    });
+    parentDbObjects.forEach((db_info) => {
+      ancestryFilePaths.push({
+        path: `x_view_ancestry/${db_info.owner_id}/${db_info.db_id}`,
+        source_id: db_info.db_id,
+        owner_id: db_info.owner_id,
+        isSceneFile: false
+      });
+    });
+    const ancestryPromises = ancestryFilePaths.map((file) => db_services.get_file(file.path));
+    const ancestryResults = await Promise.allSettled(ancestryPromises);
+    const ancestriesFromSceneFile = [];
+    const ancestriesFromDbFiles = [];
+    ancestryResults.forEach((result, index) => {
+      var _a2;
+      const fileInfo = ancestryFilePaths[index];
+      if (result.status === "fulfilled" && ((_a2 = result.value) == null ? void 0 : _a2.success) && Array.isArray(result.value.data)) {
+        const ancestriesFromFile = result.value.data.map((ancestry) => {
+          const existingSource = ancestry._source_file_id;
+          const existingOwner = ancestry._source_owner_id;
+          const isImportedItem = existingSource && existingSource !== fileInfo.source_id;
+          return {
+            ...ancestry,
+            _source_file_id: isImportedItem ? existingSource : fileInfo.source_id,
+            _source_owner_id: isImportedItem ? existingOwner : fileInfo.owner_id
+          };
+        });
+        if (fileInfo.isSceneFile) {
+          ancestriesFromSceneFile.push(...ancestriesFromFile);
+        } else {
+          ancestriesFromDbFiles.push(...ancestriesFromFile);
+        }
+      }
+    });
+    const ancestryMap = /* @__PURE__ */ new Map();
+    ancestriesFromDbFiles.forEach((anc) => ancestryMap.set(anc.ancestry_id, anc));
+    ancestriesFromSceneFile.forEach((anc) => ancestryMap.set(anc.ancestry_id, anc));
+    let ancestryData = Array.from(ancestryMap.values());
+    const externalSourcesToRefresh = /* @__PURE__ */ new Map();
+    ancestryData.forEach((anc) => {
+      const targetSourceId = anc._source_file_id || anc._imported_from_view_id;
+      const targetOwnerId = anc._source_owner_id || anc._imported_from_view_owner_id;
+      if (targetSourceId && targetSourceId !== scene_config && targetOwnerId) {
+        const isAlreadyLoadedAsParent = parentDbObjects.some((db) => String(db.db_id) === String(targetSourceId));
+        if (!isAlreadyLoadedAsParent) {
+          const key = `${targetOwnerId}/${targetSourceId}`;
+          externalSourcesToRefresh.set(key, {
+            owner_id: targetOwnerId,
+            source_id: targetSourceId,
+            key
+          });
+        }
+      }
+    });
+    const successfullyFetchedSources = /* @__PURE__ */ new Set();
+    const failedSources = /* @__PURE__ */ new Set();
+    if (externalSourcesToRefresh.size > 0) {
+      const refreshPromises = Array.from(externalSourcesToRefresh.values()).map(
+        (src) => db_services.get_file(`x_view_ancestry/${src.owner_id}/${src.source_id}`).then((res) => ({ ...res, _meta_key: src.key }))
+      );
+      const refreshResults = await Promise.allSettled(refreshPromises);
+      const freshAncestryMap = /* @__PURE__ */ new Map();
+      refreshResults.forEach((result) => {
+        var _a2, _b2;
+        if (result.status === "fulfilled" && ((_a2 = result.value) == null ? void 0 : _a2.success) && Array.isArray(result.value.data)) {
+          successfullyFetchedSources.add(result.value._meta_key);
+          result.value.data.forEach((freshAnc) => {
+            if (!freshAnc.is_private) {
+              freshAncestryMap.set(String(freshAnc.ancestry_id), freshAnc);
+            }
+          });
+        } else if (result.status === "fulfilled" && !((_b2 = result.value) == null ? void 0 : _b2.success)) {
+          failedSources.add(result.value._meta_key);
+        }
+      });
+      ancestryData = ancestryData.filter((localAnc) => {
+        const targetSourceId = localAnc._source_file_id || localAnc._imported_from_view_id;
+        const targetOwnerId = localAnc._source_owner_id || localAnc._imported_from_view_owner_id;
+        if (!targetSourceId || targetSourceId === scene_config) return true;
+        const key = `${targetOwnerId}/${targetSourceId}`;
+        if (failedSources.has(key)) {
+          return false;
+        }
+        if (externalSourcesToRefresh.has(key) && successfullyFetchedSources.has(key)) {
+          const stillExists = freshAncestryMap.has(String(localAnc.ancestry_id));
+          return stillExists;
+        }
+        return true;
+      }).map((localAnc) => {
+        const freshVersion = freshAncestryMap.get(String(localAnc.ancestry_id));
+        if (freshVersion) {
+          return {
+            ...freshVersion,
+            _imported_from_view_id: localAnc._imported_from_view_id,
+            _imported_from_view_owner_id: localAnc._imported_from_view_owner_id,
+            _origin_db_ids: localAnc._origin_db_ids,
+            _source_file_id: localAnc._source_file_id,
+            _source_owner_id: localAnc._source_owner_id
+          };
+        }
+        return localAnc;
+      });
+    }
+    const ancestryFilePath = `x_view_ancestry/${owner_id}/${scene_config}`;
+    const parentNodeIds = new Set(allNodes.map((node) => String(node.id)));
+    const pruneTree = (node) => {
+      if (!node) return null;
+      if (node.is_section) {
+        const validChildren2 = (node.children || []).map((child) => pruneTree(child)).filter(Boolean);
+        return { ...node, children: validChildren2 };
+      }
+      if (!parentNodeIds.has(String(node.node_id))) {
+        return null;
+      }
+      const validChildren = (node.children || []).map((child) => pruneTree(child)).filter(Boolean);
+      let validBranches = [];
+      if (node.parallel_branches) {
+        validBranches = node.parallel_branches.map((branch) => ({
+          ...branch,
+          tree: pruneTree(branch.tree)
+        })).filter((b) => b.tree !== null);
+      }
+      return {
+        ...node,
+        children: validChildren,
+        parallel_branches: validBranches
+      };
+    };
+    const originalAncestryDataString = JSON.stringify(Array.from(ancestryMap.values()));
+    const cleanedAncestryData = ancestryData.map((ancestry) => {
+      if (!parentNodeIds.has(String(ancestry.ancestral_node))) return null;
+      const cleanedTree = pruneTree(ancestry.tree);
+      if (!cleanedTree) return null;
+      let cleanedAbstraction = null;
+      if (ancestry.abstraction_tree) {
+        cleanedAbstraction = pruneTree(ancestry.abstraction_tree);
+      }
+      return {
+        ...ancestry,
+        tree: cleanedTree,
+        abstraction_tree: cleanedAbstraction
+      };
+    }).filter(Boolean);
+    if (JSON.stringify(cleanedAncestryData) !== originalAncestryDataString) {
+      ancestryData = cleanedAncestryData;
+      try {
+        await db_services.save_file(ancestryFilePath, ancestryData);
+      } catch (saveError) {
+        console.error("Falha ao salvar o arquivo de ancestralidade da cena atualizado:", saveError);
+      }
+    }
+    if (!isFullMember) {
+      const requiredNodeIds = /* @__PURE__ */ new Set();
+      const requiredAncestryIds = /* @__PURE__ */ new Set();
+      if (focusNodeId) requiredNodeIds.add(String(focusNodeId));
+      if (focusAncestryId) requiredAncestryIds.add(String(focusAncestryId));
+      const allNodesFromDb = Object.values(parentData).flatMap((db) => db.nodes || []);
+      const extractDependenciesFromText = (text) => {
+        if (!text) return;
+        const mentionRegex = /\[\[MENTION:node:([a-zA-Z0-9\-_]+)\]\]/g;
+        const refRegex = /\[\[REF:(node|ancestry):([a-zA-Z0-9\-_]+):([a-zA-Z0-9\-_]+)\]\]/g;
+        let match;
+        while ((match = mentionRegex.exec(text)) !== null) {
+          requiredNodeIds.add(match[1]);
+        }
+        while ((match = refRegex.exec(text)) !== null) {
+          if (match[1] === "node") requiredNodeIds.add(match[2]);
+          if (match[1] === "ancestry") requiredAncestryIds.add(match[2]);
+        }
+      };
+      const extractTreeDependencies = (treeItem) => {
+        var _a2;
+        if (!treeItem) return;
+        if (treeItem.node_id) requiredNodeIds.add(String(treeItem.node_id));
+        if ((_a2 = treeItem.node) == null ? void 0 : _a2.id) requiredNodeIds.add(String(treeItem.node.id));
+        if (treeItem.children) {
+          treeItem.children.forEach(extractTreeDependencies);
+        }
+        if (treeItem.parallel_branches) {
+          treeItem.parallel_branches.forEach((branch) => {
+            if (branch.linked_ancestry_id) {
+              requiredAncestryIds.add(String(branch.linked_ancestry_id));
+            }
+            if (branch.description) extractDependenciesFromText(branch.description);
+            if (branch.description_sections) {
+              branch.description_sections.forEach((s) => extractDependenciesFromText(s.content));
+            }
+            extractTreeDependencies(branch.tree);
+          });
+        }
+      };
+      let previousSize;
+      do {
+        previousSize = requiredNodeIds.size + requiredAncestryIds.size;
+        requiredAncestryIds.forEach((ancId) => {
+          const anc = ancestryData.find((a) => String(a.ancestry_id) === ancId);
+          if (anc && !anc.is_private) {
+            if (anc.description) extractDependenciesFromText(anc.description);
+            if (anc.description_sections) {
+              anc.description_sections.forEach((s) => extractDependenciesFromText(s.content));
+            }
+            extractTreeDependencies(anc.tree);
+            extractTreeDependencies(anc.abstraction_tree);
+          }
+        });
+        requiredNodeIds.forEach((nodeId) => {
+          const node = allNodesFromDb.find((n) => String(n.id) === nodeId);
+          if (node) {
+            if (node.description) extractDependenciesFromText(node.description);
+            if (node.description_sections) {
+              node.description_sections.forEach((s) => extractDependenciesFromText(s.content));
+            }
+          }
+        });
+      } while (requiredNodeIds.size + requiredAncestryIds.size > previousSize);
+      const restrictedSceneData = { ...validatedSceneData, nodes: [], links: [] };
+      const restrictedParentData = {};
+      const restrictedAncestryData = ancestryData.filter((a) => requiredAncestryIds.has(String(a.ancestry_id)) && !a.is_private);
+      for (const [dbId, dbContent] of Object.entries(parentData)) {
+        const filteredNodes = (dbContent.nodes || []).filter((n) => requiredNodeIds.has(String(n.id)));
+        if (filteredNodes.length > 0) {
+          restrictedParentData[dbId] = { ...dbContent, nodes: filteredNodes, links: [] };
+        }
+      }
+      if (focusNodeId) {
+        const mainNode = allNodesFromDb.find((n) => String(n.id) === String(focusNodeId));
+        if (mainNode) {
+          restrictedSceneData.nodes = [mainNode];
+        }
+      }
+      return {
+        success: true,
+        data: {
+          scene: restrictedSceneData,
+          parent: restrictedParentData,
+          ancestry: restrictedAncestryData
+        }
+      };
+    }
+    return {
+      success: true,
+      data: { scene: validatedSceneData, parent: parentData, ancestry: ancestryData }
+    };
+  } catch (error) {
+    console.error("Erro em get_scene_view_data_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function import_parent_file_modal_get_logic(db_services, session) {
+  try {
+    const call_firestore_get_x_view_data = await db_services.get_firestore_data(session);
+    const x_view_databases = call_firestore_get_x_view_data.data.sub_collections.x_view_databases || [];
+    const x_views = call_firestore_get_x_view_data.data.sub_collections.x_views || [];
+    return {
+      success: true,
+      data: {
+        databases: x_view_databases,
+        views: x_views
+      }
+    };
+  } catch (error) {
+    console.error("catch (error) em import_parent_file_modal_get_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function get_single_parent_file_logic(db_services, file_id, session) {
+  try {
+    const call_GCP_cloud_storage_get_file = await db_services.get_file(`x_view_dbs/${session.user.id}/${file_id}`);
+    return call_GCP_cloud_storage_get_file;
+  } catch (error) {
+    console.error("catch (error) em get_single_parent_file_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function x_view_add_new_parent_file_to_scene_at_firebase(file_id, session, new_parent, db_services) {
+  try {
+    const update_data = {
+      scene_id: file_id,
+      new_parent,
+      session
+    };
+    const call_firestore_add_new_parent_file_to_scene_at_firebase = await db_services.add_new_parent_file_to_scene_at_firebase(update_data);
+    return call_firestore_add_new_parent_file_to_scene_at_firebase;
+  } catch (error) {
+    console.error("catch (error) em get_single_parent_file_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function get_ancestry_file_logic(db_services, file_id, owner_id) {
+  try {
+    const path = `x_view_ancestry/${owner_id}/${file_id}`;
+    const call_GCP_cloud_storage_get_file = await db_services.get_file(path);
+    return call_GCP_cloud_storage_get_file;
+  } catch (error) {
+    console.error("catch (error) em get_ancestry_file_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function save_ancestry_board_logic(db_services, scene_id, type, groups, session, owner_id) {
+  try {
+    const targetOwnerId = owner_id || session.user.id;
+    return await db_services.save_ancestry_board(session, scene_id, type, groups, targetOwnerId);
+  } catch (error) {
+    console.error("Erro em save_ancestry_board_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function get_ancestry_board_logic(db_services, scene_id, type, session, owner_id) {
+  try {
+    const targetOwnerId = owner_id || session.user.id;
+    return await db_services.get_ancestry_board(session, scene_id, type, targetOwnerId);
+  } catch (error) {
+    console.error("Erro em get_ancestry_board_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function delete_uploaded_file_logic(db_services, fileUrl) {
+  try {
+    if (db_services.delete_public_file) {
+      return await db_services.delete_public_file(fileUrl);
+    }
+    return { success: false, error: "Servi\xE7o de dele\xE7\xE3o n\xE3o configurado." };
+  } catch (error) {
+    console.error("Erro em delete_uploaded_file_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+async function get_view_members_logic(db_services, ownerId, type, itemId) {
+  try {
+    if (!db_services.get_view_members) {
+      return { success: false, error: "Servi\xE7o de busca de membros n\xE3o configurado." };
+    }
+    return await db_services.get_view_members(ownerId, type, itemId);
+  } catch (error) {
+    console.error("Erro em get_view_members_logic:", error);
+    return { success: false, error: error.message };
+  }
+}
+export {
+  delete_uploaded_file_logic,
+  get_ancestry_board_logic,
+  get_ancestry_file_logic,
+  get_scene_view_data_logic,
+  get_single_parent_file_logic,
+  get_view_members_logic,
+  import_parent_file_modal_get_logic,
+  save_ancestry_board_logic,
+  save_view_data_logic,
+  x_view_add_new_parent_file_to_scene_at_firebase
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lv-x-software-house/x_view",
-  "version": "1.2.6-dev.2",
+  "version": "1.2.6-dev.21",
   "description": "Pacote privado contendo os componentes e lógica de renderização 3D do X View.",
   "author": "iv.x - Engenharia de Software - ivxsoftwarehouse@gmail.com",
   "license": "UNLICENSED",
@@ -35,8 +35,7 @@
     "@eslint/js": "^9.39.4",
     "@types/crypto-js": "^4.2.2",
     "@types/node": "^22.5.4",
-    "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.2.3",
+    "@types/react": "^18.3.5",
     "@types/three": "^0.179.0",
     "eslint": "^9.39.4",
     "eslint-config-prettier": "^10.1.8",
@@ -50,14 +49,7 @@
   },
   "dependencies": {
     "@casl/ability": "^6.8.0",
-    "@tiptap/core": "^3.22.2",
-    "@tiptap/extension-mention": "^3.22.2",
-    "@tiptap/pm": "^3.22.2",
-    "@tiptap/react": "^3.22.2",
-    "@tiptap/starter-kit": "^3.22.2",
-    "@tiptap/suggestion": "^3.22.2",
     "react-colorful": "^5.6.1",
-    "tippy.js": "^6.3.7",
     "uuid": "^13.0.0"
   }
 }