Spaces:
Sleeping
Sleeping
| import fs from "node:fs"; | |
| import path from "node:path"; | |
| import vm from "node:vm"; | |
| import { fileURLToPath } from "node:url"; | |
| const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); | |
| const html = fs.readFileSync(path.join(root, "index.html"), "utf8"); | |
| function expression(name, pattern) { | |
| const match = html.match(pattern); | |
| if (!match) throw new Error(`Não foi possível extrair ${name}.`); | |
| return vm.runInNewContext(`(${match[1]})`); | |
| } | |
| const savedDefault = expression("savedDefault", /const savedDefault=(\[[^\n]+\]);/); | |
| const areaById = expression("areaById", /const areaById=({[^\n]+});/); | |
| const savedPinPositions = expression("savedPinPositions", /const savedPinPositions=({[^\n]+});/); | |
| const upperDefault = expression("upperDefault", /const upperDefault=(\(\(\)=>\{[\s\S]*?\}\)\(\));/); | |
| const accessoryLinks = expression("TPU_ACCESSORY_LINKS", /const TPU_ACCESSORY_LINKS=({[^\n]+});/); | |
| const baseLinks = expression("TPU_BASE_LINKS", /const TPU_BASE_LINKS=({[^\n]+});/); | |
| const requiredStores = expression("REQUIRED_ACCESSORY_STORES", /const REQUIRED_ACCESSORY_STORES=(\[[\s\S]*?\n\]);/); | |
| const requiredTpus = expression("REQUIRED_TPUS", /const REQUIRED_TPUS=(\[[^\n]+\]);/); | |
| const context = { window: {} }; | |
| vm.createContext(context); | |
| vm.runInContext(fs.readFileSync(path.join(root, "tpu_mpc_v4_data.js"), "utf8"), context); | |
| vm.runInContext(fs.readFileSync(path.join(root, "tpu_area_details.js"), "utf8"), context); | |
| const imported = context.window.MP_IMPORTED_TPUS; | |
| const details = context.window.MP_TPU_DETAILS.byId; | |
| const quadrantNames = { | |
| 74: "DEP 6 (I)", 103: "BOX 1 (IV)", 120: "DEP (II)", | |
| 135: "DEP 2 (III)", 136: "DEP 3 (III)", 137: "DEP 4 (III)", | |
| 138: "DEP 5 (III)", 139: "DEP 1 (III)", | |
| }; | |
| function spaceType(name) { | |
| const normalized = String(name).normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase(); | |
| const number = normalized.match(/^(?:LOJ|LOJA|LJ)\s*0*(\d+)/); | |
| if (number && ["16", "18", "20"].includes(String(Number(number[1])))) return "SUBSTACAO"; | |
| if (normalized.startsWith("LOJ")) return "LOJ"; | |
| if (normalized.startsWith("BC")) return "BC"; | |
| if (normalized.startsWith("BP")) return "BP"; | |
| if (normalized.startsWith("AM") || normalized.startsWith("MI")) return "AM"; | |
| if (normalized.startsWith("PATIO")) return "PATIO"; | |
| if (normalized.startsWith("BOX")) return "BOX"; | |
| if (normalized.startsWith("DEP")) return "DEP"; | |
| if (normalized.startsWith("LED")) return "LED"; | |
| if (normalized.startsWith("REST")) return "REST"; | |
| if (normalized.startsWith("CON")) return "CON"; | |
| return "OUTRO"; | |
| } | |
| const types = [ | |
| ["LOJ", "Loja", "#F6D5C5", 1], ["BC", "Banca", "#CDE8D6", 1], | |
| ["BP", "Banca do peixe", "#DCD5F2", 1], ["AM", "Área de mesa", "#F7E7B8", .85], | |
| ["PATIO", "Pátio", "#CFE3F4", 1], ["BOX", "Box", "#F4C7C3", 1], | |
| ["DEP", "Depósito", "#D7E1EA", .75], ["LED", "Painel LED", "#FFE08A", 1], | |
| ["REST", "Restaurante", "#F3D3E0", 1], ["CON", "Concessão", "#CDEBE7", 1], | |
| ["SUBSTACAO", "Subestação", "#D9D2E9", 1], ["OUTRO", "Outro", "#FFFFFF", 1], | |
| ].map(([code, label, color, coefficient]) => ({ code, label, color, coefficient })); | |
| function normalizeSpace(raw, floorId) { | |
| const corrected = floorId === "ground" | |
| ? (quadrantNames[Number(raw.id)] || (Number(raw.id) === 145 && raw.name.trim().toUpperCase() === "AM PIII-1" ? "AM PIII-2" : raw.name)) | |
| : raw.name; | |
| const pin = floorId === "ground" ? savedPinPositions[raw.id] : null; | |
| const x = Number.isFinite(Number(raw.pinX)) ? Number(raw.pinX) : pin?.[0] ?? ((raw.col - 1 + raw.width / 2) / 42); | |
| const y = Number.isFinite(Number(raw.pinY)) ? Number(raw.pinY) : pin?.[1] ?? ((raw.row - 1 + raw.height / 2) / 43); | |
| return { | |
| id: `${floorId}:${raw.id}`, | |
| legacy_id: Number(raw.id), | |
| floor_id: floorId, | |
| name: corrected, | |
| type: spaceType(corrected), | |
| base_area_m2: Number((floorId === "ground" ? areaById[raw.id] : raw.area) || 0), | |
| position: { x: Number(x.toFixed(7)), y: Number(y.toFixed(7)) }, | |
| grid: { col: Number(raw.col), row: Number(raw.row), width: Number(raw.width), height: Number(raw.height) }, | |
| components: { mezzanine: 0, deposit: 0, deck: 0, table: 0 }, | |
| }; | |
| } | |
| const groundById = new Map(savedDefault.map(item => [Number(item.id), item])); | |
| for (const item of requiredStores) if (!groundById.has(Number(item.id))) groundById.set(Number(item.id), item); | |
| const spaces = [ | |
| ...[...groundById.values()].map(item => normalizeSpace(item, "ground")), | |
| ...upperDefault.map(item => normalizeSpace(item, "upper")), | |
| ]; | |
| function splitBoxes(items) { | |
| const combined = items.find(t => Number(t.id) === 400115); | |
| if (!combined) return items; | |
| const boxes = [103, 147, 148, 149, 150, 151, 152, 153]; | |
| const deposits = [154, 155, 156, 157, 158, 159, 160, 161]; | |
| const tables = [162, 163, 164, 165, 166, 167, 168, 169]; | |
| const ids = [400115, 400129, 400130, 400131, 400132, 400133, 400134, 400135]; | |
| const replacements = ids.map((id, index) => ({ | |
| ...combined, | |
| id, | |
| name: `TPU_BOX_${index + 1}_IV`, | |
| storeIds: [boxes[index], deposits[index], tables[index]], | |
| baseStoreIds: [boxes[index]], | |
| accessoryStoreIds: [deposits[index], tables[index]], | |
| linkedFloor: null, | |
| linkedStoreIds: [], | |
| allocationRefs: [{ floor: "ground", id: boxes[index] }], | |
| sourceOrder: String(112 + index), sourceGrossArea: 19.62, | |
| sourceUnitAreas: [9.52], sourceMezzanine: 0, sourceDeposit: 7.4, | |
| sourceDeck: 0, sourceTableArea: 2.7, sourceWeightedArea: 17.365, | |
| sourceArea: 17.365, | |
| })); | |
| return items.filter(t => Number(t.id) !== 400115).concat(replacements); | |
| } | |
| const rawByFloor = { | |
| ground: splitBoxes(imported.ground).concat(requiredTpus), | |
| upper: imported.upper, | |
| }; | |
| const tpuMap = new Map(); | |
| for (const [floorId, items] of Object.entries(rawByFloor)) { | |
| for (const raw of items) { | |
| const merged = { ...(details[String(raw.id)] || {}), ...raw }; | |
| let target = tpuMap.get(String(raw.id)); | |
| if (!target) { | |
| const source = {}; | |
| for (const [key, value] of Object.entries(merged)) { | |
| if (key.startsWith("source")) source[key.slice(6, 7).toLowerCase() + key.slice(7)] = value; | |
| } | |
| source.allocationRefs = (merged.allocationRefs || []).map(ref => `${ref.floor}:${ref.id}`); | |
| target = { | |
| id: String(raw.id), legacy_id: Number(raw.id), name: raw.name, | |
| color: raw.color || "#5B8DB8", members: [], source, | |
| visual_links: [], | |
| }; | |
| tpuMap.set(String(raw.id), target); | |
| } | |
| const accessories = new Set(merged.accessoryStoreIds || (floorId === "ground" ? accessoryLinks[raw.id] || [] : [])); | |
| const bases = new Set(merged.baseStoreIds || [ | |
| ...(raw.storeIds || []).filter(id => !accessories.has(id)), | |
| ...(floorId === "ground" ? baseLinks[raw.id] || [] : []), | |
| ]); | |
| const localIds = new Set([...bases, ...accessories, ...(raw.storeIds || [])]); | |
| for (const id of localIds) { | |
| const member = { space_id: `${floorId}:${id}`, role: accessories.has(id) ? "accessory" : "base" }; | |
| if (!target.members.some(item => item.space_id === member.space_id)) target.members.push(member); | |
| } | |
| if (raw.linkedFloor) { | |
| for (const id of raw.linkedStoreIds || []) { | |
| const spaceId = `${raw.linkedFloor}:${id}`; | |
| if (!target.members.some(item => item.space_id === spaceId)) target.members.push({ space_id: spaceId, role: "base" }); | |
| } | |
| } | |
| } | |
| } | |
| const document = { | |
| schema_version: 1, | |
| revision: 0, | |
| updated_at: new Date().toISOString(), | |
| floors: [ | |
| { id: "ground", name: "Térreo", image: "/plants/planta_terreo_mercado_publico.png", width: 1200, height: 1189, order: 1 }, | |
| { id: "upper", name: "2º pavimento", image: "/plants/planta_segundo_pavimento_mercado_publico.png", width: 1200, height: 1184, order: 2 }, | |
| ], | |
| space_types: types, | |
| component_types: [ | |
| { code: "mezzanine", label: "Mezanino", coefficient: .75 }, | |
| { code: "deposit", label: "Depósito", coefficient: .75 }, | |
| { code: "deck", label: "Deck", coefficient: .30 }, | |
| { code: "table", label: "Área de mesa", coefficient: .85 }, | |
| ], | |
| spaces, | |
| tpus: [...tpuMap.values()], | |
| settings: { active_floor: "ground", show_tpu_links: true }, | |
| }; | |
| const spacesById = new Map(document.spaces.map(space => [space.id, space])); | |
| for (const tpu of document.tpus) { | |
| const refs = tpu.source.allocationRefs || []; | |
| if (!refs.length) continue; | |
| const units = (tpu.source.unitAreas || []).map(Number).filter(value => value > 0); | |
| let bases; | |
| if (units.length === refs.length) { | |
| bases = units; | |
| } else if (refs.length === 1) { | |
| bases = [units.reduce((sum, value) => sum + value, 0) || spacesById.get(refs[0])?.base_area_m2 || 0]; | |
| } else { | |
| const mapped = refs.map(ref => spacesById.get(ref)?.base_area_m2 || 0); | |
| const mappedTotal = mapped.reduce((sum, value) => sum + value, 0); | |
| const unitTotal = units.reduce((sum, value) => sum + value, 0); | |
| bases = mapped.map(value => mappedTotal ? unitTotal * value / mappedTotal : unitTotal / refs.length); | |
| } | |
| const memberSpaces = tpu.members.map(member => ({ ...member, space: spacesById.get(member.space_id) })).filter(item => item.space); | |
| const depositAccessories = memberSpaces.filter(item => item.role === "accessory" && item.space.type === "DEP"); | |
| const tableAccessories = memberSpaces.filter(item => item.role === "accessory" && item.space.type === "AM"); | |
| const hasDepositAccessory = depositAccessories.length > 0; | |
| const hasTableAccessory = tableAccessories.length > 0; | |
| for (const item of depositAccessories) { | |
| item.space.base_area_m2 = Number((Number(tpu.source.deposit || 0) / depositAccessories.length).toFixed(4)); | |
| item.space.components = { mezzanine: 0, deposit: 0, deck: 0, table: 0 }; | |
| } | |
| for (const item of tableAccessories) { | |
| item.space.base_area_m2 = Number((Number(tpu.source.tableArea || 0) / tableAccessories.length).toFixed(4)); | |
| item.space.components = { mezzanine: 0, deposit: 0, deck: 0, table: 0 }; | |
| } | |
| const baseTotal = bases.reduce((sum, value) => sum + value, 0) || refs.length; | |
| refs.forEach((ref, index) => { | |
| const space = spacesById.get(ref); | |
| if (!space) return; | |
| const share = baseTotal ? bases[index] / baseTotal : 1 / refs.length; | |
| space.base_area_m2 = Number((bases[index] || 0).toFixed(4)); | |
| space.components = { | |
| mezzanine: Number((Number(tpu.source.mezzanine || 0) * share).toFixed(4)), | |
| deposit: hasDepositAccessory ? 0 : Number((Number(tpu.source.deposit || 0) * share).toFixed(4)), | |
| deck: Number((Number(tpu.source.deck || 0) * share).toFixed(4)), | |
| table: hasTableAccessory ? 0 : Number((Number(tpu.source.tableArea || 0) * share).toFixed(4)), | |
| }; | |
| }); | |
| } | |
| const output = path.join(root, "seed", "default.json"); | |
| fs.writeFileSync(output, `${JSON.stringify(document, null, 2)}\n`); | |
| console.log(`Seed criado: ${spaces.length} espaços, ${document.tpus.length} TPUs.`); | |