585 lines
28 KiB
JavaScript
585 lines
28 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* به‌روزرسانی یک‌بارهٔ پالت `style.json` نقشهٔ آفلاین روی MinIO.
|
|
*
|
|
* ترتیب کار (مهم): اول نسخهٔ فعلی خوانده و «پشتیبان» می‌شود — هم روی دیسک
|
|
* (style.backup.json) و هم روی MinIO (maps/style.backup.json) — و تنها پس از
|
|
* موفقیت پشتیبان، پالت تازه نوشته و آپلود می‌شود.
|
|
*
|
|
* چرا از S3 API و نه فایل روی دیسک؟ شیءهای MinIO با فرمت داخلی xl.meta ذخیره
|
|
* می‌شوند، نه JSON خام؛ پس تنها راه درست به‌روزرسانی، PUT روی همان API است.
|
|
*
|
|
* اجرا (از پوشهٔ frontend) — هر کار با پرچم مشخص، پیش‌فرض هیچ تغییری نمی‌دهد:
|
|
* node --experimental-strip-types scripts/update-map-palette.ts --fix-glyphs
|
|
* node --experimental-strip-types scripts/update-map-palette.ts --palette
|
|
* node --experimental-strip-types scripts/update-map-palette.ts --restore
|
|
* ... [--dry-run] برای دیدن گزارش بدون نوشتن روی MinIO
|
|
*
|
|
* در همهٔ حالت‌ها (جز restore) ترتیب امن رعایت می‌شود: خواندن و اعتبارسنجی →
|
|
* پشتیبان روی دیسک و MinIO → تغییر → اعتبارسنجی دوباره → آپلود.
|
|
*
|
|
* کلیدهای MinIO از فایل .env ریشهٔ پروژه خوانده می‌شوند (MINIO_ROOT_USER /
|
|
* MINIO_ROOT_PASSWORD) و در نبودشان از متغیرهای محیطی همان نام‌ها.
|
|
*/
|
|
|
|
import { createHash, createHmac } from 'node:crypto'
|
|
import { mkdir, readFile, writeFile } from 'node:fs/promises'
|
|
import { dirname, join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* پالت تازه */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
/** نگاشت دسته‌ها به رنگ‌های تازهٔ برند — تنها منبع حقیقت این اسکریپت */
|
|
const PALETTE = {
|
|
background: '#181512',
|
|
urban: '#27221c',
|
|
highway: '#6a5544',
|
|
street: '#4a3a2d',
|
|
alley: '#352c25',
|
|
water: '#172c32',
|
|
parks: '#20312b',
|
|
nature: '#314238',
|
|
mainText: '#ead9c6',
|
|
subText: '#a99584',
|
|
borders: '#3e362e',
|
|
} as const
|
|
|
|
type Category = keyof typeof PALETTE
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* قواعد دسته‌بندی لایه‌ها */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
type Layer = {
|
|
id: string
|
|
type: string
|
|
'source-layer'?: string
|
|
paint?: Record<string, unknown>
|
|
layout?: Record<string, unknown>
|
|
}
|
|
type StyleDocument = {
|
|
version?: number
|
|
layers?: Layer[]
|
|
sources?: Record<string, unknown>
|
|
/** الگوی نشانی گلیف‌ها — باید به پوشهٔ v2.0 باکت اشاره کند */
|
|
glyphs?: string
|
|
}
|
|
|
|
/** پوشهٔ فونت‌های آفلاین در باکت MinIO */
|
|
const GLYPHS_FOLDER = 'v2.0'
|
|
/** الگوی استاندارد گلیف — جانگهدارها دست‌نخورده می‌مانند */
|
|
const GLYPH_TEMPLATE = '{fontstack}/{range}.pbf'
|
|
|
|
/**
|
|
* اصلاح مسیر گلیف‌ها: هر شکل نشانی (خالی، نسبی، یا با پوشهٔ اشتباه) به
|
|
* «v2.0/{fontstack}/{range}.pbf» تبدیل می‌شود تا با ساختار پوشه‌های باکت
|
|
* بخواند. تابع خالص و idempotent است؛ اگر مسیر از قبل درست باشد چیز تغییر نمی‌کند.
|
|
*/
|
|
function fixGlyphsPath(style: StyleDocument): { from: string; to: string } | null {
|
|
const current = (style.glyphs ?? '').trim()
|
|
const marker = current.indexOf('{fontstack}')
|
|
const next = `${GLYPHS_FOLDER}/${marker >= 0 ? current.slice(marker) : GLYPH_TEMPLATE}`
|
|
if (next === current) return null
|
|
style.glyphs = next
|
|
return { from: current || '(خالی)', to: next }
|
|
}
|
|
|
|
/** آیا مقدار text-field به یک فیلد «نام» اشاره می‌کند؟ (name، name_en، name:latin و…) */
|
|
const NAME_REFERENCE = /name(:[a-z-]+)?/i
|
|
|
|
/**
|
|
* فونت‌های محلی با پوشش فارسی — با اجرای «--audit-fonts» قابل بازبینی است.
|
|
* تنها پوشه‌های Noto Sans در باکت گلیف عربی/فارسی دارند؛ Metropolis و بقیه
|
|
* فقط لاتین‌اند.
|
|
*/
|
|
const PERSIAN_CAPABLE_FONTS = ['Noto Sans Regular', 'Noto Sans Italic', 'Noto Sans Bold']
|
|
|
|
/**
|
|
* بازگردانی متن برچسب‌ها به قالب دوزبانهٔ اصلی، به‌تفکیک لایه.
|
|
* (لاتین خط اول، فارسی خط دوم — یا کنار هم برای نام راه‌ها)
|
|
*/
|
|
const TEXT_FIELD_RESTORE: Record<string, string> = {
|
|
water_name: '{name:latin}\n{name:nonlatin}',
|
|
place_other: '{name:latin}\n{name:nonlatin}',
|
|
place_suburb: '{name:latin}\n{name:nonlatin}',
|
|
place_village: '{name:latin}\n{name:nonlatin}',
|
|
place_town: '{name:latin}\n{name:nonlatin}',
|
|
place_city: '{name:latin}\n{name:nonlatin}',
|
|
place_city_large: '{name:latin}\n{name:nonlatin}',
|
|
place_state: '{name:latin}\n{name:nonlatin}',
|
|
highway_name_other: '{name:latin} {name:nonlatin}',
|
|
place_country_other: '{name:latin}',
|
|
place_country_minor: '{name:latin}',
|
|
place_country_major: '{name:latin}',
|
|
}
|
|
|
|
/** قالب پیش‌فرض برای هر لایهٔ برچسبِ دیگری که بعداً اضافه شود */
|
|
const DEFAULT_BILINGUAL_FIELD = '{name:latin}\n{name:nonlatin}'
|
|
|
|
function referencesName(value: unknown): boolean {
|
|
if (typeof value === 'string') return NAME_REFERENCE.test(value)
|
|
if (Array.isArray(value)) return value.some(referencesName)
|
|
if (value && typeof value === 'object') return Object.values(value).some(referencesName)
|
|
return false
|
|
}
|
|
|
|
/** فونت فارسی متناسب با پشتهٔ همان لایه — ایتالیک بماند ایتالیک */
|
|
function persianFontFor(stack: string[]): string {
|
|
const local = stack.find((font) => PERSIAN_CAPABLE_FONTS.includes(font))
|
|
if (local) return local
|
|
return stack.some((font) => /italic/i.test(font)) ? 'Noto Sans Italic' : 'Noto Sans Regular'
|
|
}
|
|
|
|
type LabelChange = { id: string; field?: { from: string; to: string }; font: { from: string; to: string } }
|
|
|
|
/**
|
|
* آماده‌سازی برچسب‌ها برای فارسی:
|
|
* ۱) متن به قالب دوزبانهٔ اصلی برمی‌گردد (لاتین + nonlatin که برای دادهٔ ایران فارسی است).
|
|
* ۲) پشتهٔ فونت بازچینی می‌شود تا فونت دارای گلیف فارسی (Noto Sans محلی) اول بیفتد؛
|
|
* چون مپ‌لیبر برای هر پشته فقط یک فایل گلیف می‌گیرد، همان فونت اول باید هر دو خط
|
|
* را پوشش دهد و Noto Sans لاتین را هم دارد.
|
|
*/
|
|
function fixLabels(style: StyleDocument): { changed: LabelChange[]; skipped: string[] } {
|
|
const changed: LabelChange[] = []
|
|
const skipped: string[] = []
|
|
|
|
for (const layer of style.layers ?? []) {
|
|
const layout = layer.layout
|
|
if (layer.type !== 'symbol' || !layout) continue
|
|
|
|
const stack = Array.isArray(layout['text-font']) ? (layout['text-font'] as unknown[]).map(String) : []
|
|
if (!stack.length) continue
|
|
|
|
const persianFont = persianFontFor(stack)
|
|
const restacked = [persianFont, ...stack.filter((font) => font !== persianFont)]
|
|
const fontChange = { from: stack.join(', '), to: restacked.join(', ') }
|
|
|
|
if (!('text-field' in layout)) {
|
|
// لایهٔ برچسب بدون فیلد نام (مثل شمارهٔ راه) — فقط پشتهٔ فونت اصلاح می‌شود
|
|
layout['text-font'] = restacked
|
|
changed.push({ id: layer.id, font: fontChange })
|
|
continue
|
|
}
|
|
|
|
if (!referencesName(layout['text-field'])) {
|
|
layout['text-font'] = restacked
|
|
skipped.push(layer.id)
|
|
continue
|
|
}
|
|
|
|
const from = JSON.stringify(layout['text-field']).slice(0, 48)
|
|
const to = TEXT_FIELD_RESTORE[layer.id] ?? DEFAULT_BILINGUAL_FIELD
|
|
layout['text-field'] = to
|
|
layout['text-font'] = restacked
|
|
changed.push({ id: layer.id, field: { from, to }, font: fontChange })
|
|
}
|
|
|
|
return { changed, skipped }
|
|
}
|
|
|
|
/**
|
|
* بررسی فونت‌ها: هر فونتی که در text-font لایه‌های برچسب استفاده شده باید در
|
|
* پوشهٔ v2.0 باکت موجود باشد — هیچ نشانی بیرونی و هیچ فونت غایبی مجاز نیست.
|
|
*/
|
|
async function verifyFonts(style: StyleDocument): Promise<void> {
|
|
const fonts = new Set<string>()
|
|
for (const layer of style.layers ?? []) {
|
|
if (layer.type !== 'symbol') continue
|
|
const stack = layer.layout?.['text-font']
|
|
if (Array.isArray(stack)) for (const font of stack) if (typeof font === 'string') fonts.add(font)
|
|
}
|
|
|
|
if (!fonts.size) {
|
|
console.log('• فونتی در لایه‌های برچسب پیدا نشد')
|
|
return
|
|
}
|
|
|
|
console.log(`\nبررسی ${fonts.size} فونت در پوشهٔ ${GLYPHS_FOLDER}:`)
|
|
const missing: string[] = []
|
|
for (const font of [...fonts].sort()) {
|
|
const url = new URL(`/maps/${GLYPHS_FOLDER}/${encodeURIComponent(font)}/0-255.pbf`, ENDPOINT)
|
|
const ok = (await fetch(url, { method: 'HEAD' })).ok
|
|
if (!ok) missing.push(font)
|
|
console.log(` ${ok ? '✓' : '✗'} ${font}`)
|
|
}
|
|
|
|
console.log(
|
|
missing.length
|
|
? `✗ فونت‌های ناموجود در ${GLYPHS_FOLDER}: ${missing.join(', ')}`
|
|
: `✓ همهٔ فونت‌ها در ${GLYPHS_FOLDER} باکت موجودند`,
|
|
)
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* بررسی پوشش فونت‌های محلی (کدام فونت فارسی را رندر می‌کند؟) */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
/** بازه‌های کلیدی گلیف: لاتین پایه، عربی/فارسی، فرم‌های نمایشی عربی */
|
|
const COVERAGE_RANGES = [
|
|
{ label: 'لاتین', range: '0-255' },
|
|
{ label: 'فارسی', range: '1536-1791' },
|
|
{ label: 'فرم فارسی', range: '65024-65279' },
|
|
] as const
|
|
|
|
/** فهرست پوشه‌های فونت داخل v2.0 باکت */
|
|
async function listFontFolders(): Promise<string[]> {
|
|
const response = await fetch(
|
|
new URL(`/maps/?list-type=2&prefix=${GLYPHS_FOLDER}/&delimiter=/&max-keys=1000`, ENDPOINT),
|
|
)
|
|
const xml = await response.text()
|
|
const pattern = new RegExp(`<Prefix>${GLYPHS_FOLDER}/([^<]+)/</Prefix>`, 'g')
|
|
return [...xml.matchAll(pattern)].map((match) => match[1])
|
|
}
|
|
|
|
/** وضعیت یک بازهٔ گلیف برای یک فونت: «نیست» / «خالی» / حجم واقعی */
|
|
async function rangeCoverage(font: string, range: string): Promise<string> {
|
|
const url = new URL(`/maps/${GLYPHS_FOLDER}/${encodeURIComponent(font)}/${range}.pbf`, ENDPOINT)
|
|
const response = await fetch(url, { method: 'HEAD' })
|
|
if (!response.ok) return 'نیست'
|
|
const bytes = Number(response.headers.get('content-length') ?? 0)
|
|
// بازهٔ بدون گلیف فقط سرصفحهٔ پروتوباف است (چند ده بایت)
|
|
return bytes > 2000 ? `${Math.round(bytes / 1024)}KB` : 'خالی'
|
|
}
|
|
|
|
/** گزارش پوشش خط‌ها برای همهٔ فونت‌های باکت — ورودی تصمیم انتخاب فونت برچسب‌ها */
|
|
async function auditFonts(): Promise<void> {
|
|
const fonts = await listFontFolders()
|
|
console.log(`${fonts.length} پوشهٔ فونت در ${GLYPHS_FOLDER}:\n`)
|
|
for (const font of fonts) {
|
|
const cells: string[] = []
|
|
for (const { label, range } of COVERAGE_RANGES) cells.push(`${label}=${await rangeCoverage(font, range)}`)
|
|
console.log(` ${font.padEnd(26)} ${cells.join(' ')}`)
|
|
}
|
|
console.log('\nفونتی که «فارسی» و «فرم فارسی» آن خالی/نیست نباشد، برچسب فارسی را رندر می‌کند.')
|
|
}
|
|
|
|
/**
|
|
* اعتبارسنجی ساختار سبک — پیش و پس از تغییر اجرا می‌شود تا مطمئن شویم سند
|
|
* سالم است و اسکیمای سبک (نسخه، لایه‌ها، منابع) نشکسته است.
|
|
*/
|
|
function validateStyle(style: StyleDocument, label: string): void {
|
|
const problems: string[] = []
|
|
if (style.version !== 8) problems.push(`version باید ۸ باشد (مقدار فعلی: ${String(style.version)})`)
|
|
if (!Array.isArray(style.layers) || style.layers.length === 0) problems.push('layers باید آرایهٔ ناتهی باشد')
|
|
else {
|
|
const broken = style.layers.filter((layer) => !layer || typeof layer.id !== 'string' || typeof layer.type !== 'string')
|
|
if (broken.length) problems.push(`${broken.length} لایه بدون id/type`)
|
|
}
|
|
if (!style.sources || typeof style.sources !== 'object' || Array.isArray(style.sources)) {
|
|
problems.push('sources باید یک شیء باشد')
|
|
}
|
|
|
|
console.log(
|
|
problems.length
|
|
? `✗ اعتبارسنجی ${label}: ${problems.join(' | ')}`
|
|
: `✓ اعتبارسنجی ${label}: ساختار سالم است (${style.layers?.length ?? 0} لایه، ${Object.keys(style.sources ?? {}).length} منبع)`,
|
|
)
|
|
if (problems.length) throw new Error(`ساختار سبک نامعتبر است (${label})`)
|
|
}
|
|
|
|
type Rule = {
|
|
category: Category
|
|
/** با این الگو روی شناسهٔ لایه تطبیق داده می‌شود */
|
|
test: RegExp
|
|
/** کدام ویژگی‌های paint رنگ‌آمیزی شوند */
|
|
properties: string[]
|
|
}
|
|
|
|
/**
|
|
* جدول قواعد — به ترتیب بررسی می‌شود و نخستین تطبیق برنده است.
|
|
* رنگ‌های داخل عبارت‌ها (interpolate/match) هم بازنویسی می‌شوند تا پالت
|
|
* یکدست بماند.
|
|
*/
|
|
const RULES: Rule[] = [
|
|
{ category: 'background', test: /^background$/, properties: ['background-color'] },
|
|
|
|
// آب: خود لایه‌های آب و راه‌های آبی (برچسب‌ها قاعدهٔ جدا دارند)
|
|
{ category: 'water', test: /^(water|waterway)(_|$)/, properties: ['fill-color', 'line-color'] },
|
|
|
|
// پارک‌ها پیش از طبیعت بررسی می‌شوند تا چمن/پارک زیر «طبیعت» نرود
|
|
{ category: 'parks', test: /^(park|landcover_grass|landuse_(park|cemetery|pitch|grass))/, properties: ['fill-color', 'line-color'] },
|
|
|
|
// طبیعت: پوشش زمینِ جنگلی/علف‌زارِ بیرون از شهر
|
|
{ category: 'nature', test: /^landcover_/, properties: ['fill-color', 'line-color'] },
|
|
|
|
// کاربری شهری و ساختمان‌ها
|
|
{ category: 'urban', test: /^landuse_/, properties: ['fill-color', 'line-color'] },
|
|
{ category: 'urban', test: /^building/, properties: ['fill-color'] },
|
|
|
|
// سه ردهٔ راه — بزرگراه، خیابان، کوچه/ریل/باند فرودگاه
|
|
{ category: 'highway', test: /^highway_motorway/, properties: ['line-color', 'fill-color'] },
|
|
{ category: 'street', test: /^(highway_(major|minor)|road_)/, properties: ['line-color', 'fill-color'] },
|
|
{ category: 'alley', test: /^(highway_(path|track)|railway|aeroway)/, properties: ['line-color', 'fill-color'] },
|
|
|
|
{ category: 'borders', test: /^boundary/, properties: ['line-color', 'fill-color'] },
|
|
|
|
// برچسب‌های اصلی: شهر/شهرک و نام بزرگراه‌ها
|
|
{ category: 'mainText', test: /^(place_(city|town)|highway_name_motorway)/, properties: ['text-color'] },
|
|
|
|
// بقیهٔ برچسب‌ها (روستا، محله، نام خیابان، نام آب، نقاط) — متن فرعی
|
|
{ category: 'subText', test: /(_name|^place_|_label)/, properties: ['text-color'] },
|
|
]
|
|
|
|
/** ویژگی‌های فرعی که همیشه با رنگ پس‌زمینه هماهنگ می‌شوند تا خوانایی بماند */
|
|
const HALO_PROPERTIES = ['text-halo-color', 'icon-halo-color']
|
|
/** ویژگی‌های آیکون برچسب‌ها که با متن هم‌رنگ می‌شوند */
|
|
const ICON_PROPERTIES = ['icon-color']
|
|
|
|
const COLOR_PATTERN = /^(#|rgb|hsl)/i
|
|
const isColor = (value: unknown): value is string => typeof value === 'string' && COLOR_PATTERN.test(value.trim())
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* بازنویسی رنگ‌ها (توابع خالص) */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
/** هر رشتهٔ رنگی داخل یک مقدار paint — حتی داخل عبارت‌ها — را با رنگ تازه عوض می‌کند */
|
|
function paintColor(value: unknown, color: string, stats: { replaced: number; seen: Set<string> }): unknown {
|
|
if (isColor(value)) {
|
|
stats.seen.add(value.trim())
|
|
stats.replaced += 1
|
|
return color
|
|
}
|
|
if (Array.isArray(value)) return value.map((item) => paintColor(item, color, stats))
|
|
if (value && typeof value === 'object') {
|
|
const result: Record<string, unknown> = {}
|
|
for (const [key, inner] of Object.entries(value)) result[key] = paintColor(inner, color, stats)
|
|
return result
|
|
}
|
|
return value
|
|
}
|
|
|
|
type LayerReport = { id: string; category: Category | null; replaced: number; colors: string[] }
|
|
|
|
/** یک لایه را بر پایهٔ قواعد رنگ‌آمیزی می‌کند و گزارش تغییرها را برمی‌گرداند */
|
|
function recolorLayer(layer: Layer): LayerReport {
|
|
const rule = RULES.find((candidate) => candidate.test.test(layer.id))
|
|
const stats = { replaced: 0, seen: new Set<string>() }
|
|
|
|
if (!layer.paint) return { id: layer.id, category: rule?.category ?? null, replaced: 0, colors: [] }
|
|
|
|
if (rule) {
|
|
for (const property of rule.properties) {
|
|
if (!(property in layer.paint)) continue
|
|
layer.paint[property] = paintColor(layer.paint[property], PALETTE[rule.category], stats)
|
|
}
|
|
}
|
|
|
|
// لایه‌های برچسب: هاله و آیکون‌ها با پالت هماهنگ می‌شوند
|
|
if (layer.type === 'symbol') {
|
|
const textColor = rule?.category === 'mainText' || rule?.category === 'subText'
|
|
? PALETTE[rule.category]
|
|
: PALETTE.subText
|
|
if (rule?.category !== 'mainText' && rule?.category !== 'subText' && 'text-color' in layer.paint) {
|
|
layer.paint['text-color'] = paintColor(layer.paint['text-color'], textColor, stats)
|
|
}
|
|
for (const property of [...HALO_PROPERTIES, ...ICON_PROPERTIES]) {
|
|
if (!(property in layer.paint)) continue
|
|
const target = property === 'icon-color' ? textColor : PALETTE.background
|
|
layer.paint[property] = paintColor(layer.paint[property], target, stats)
|
|
}
|
|
}
|
|
|
|
// لبهٔ ساختمان‌ها با رنگ مرزها هم‌خانواده می‌شود
|
|
if (layer.paint['fill-outline-color'] && /^building/.test(layer.id)) {
|
|
layer.paint['fill-outline-color'] = paintColor(layer.paint['fill-outline-color'], PALETTE.borders, stats)
|
|
}
|
|
|
|
return { id: layer.id, category: rule?.category ?? null, replaced: stats.replaced, colors: [...stats.seen] }
|
|
}
|
|
|
|
/** کل سند سبک را بازنویسی می‌کند (بدون دست‌زدن به ساختار و ویژگی‌های غیررنگی) */
|
|
function recolorStyle(style: StyleDocument): LayerReport[] {
|
|
const layers = style.layers ?? []
|
|
return layers.map(recolorLayer)
|
|
}
|
|
|
|
/** گزارش فشردهٔ تغییرهای پالت — به‌تفکیک دسته و لایه‌های دست‌نخورده */
|
|
function reportPalette(reports: LayerReport[]): void {
|
|
const byCategory = new Map<string, number>()
|
|
for (const report of reports) {
|
|
if (!report.replaced) continue
|
|
const category = report.category ?? 'بدون‌دسته'
|
|
byCategory.set(category, (byCategory.get(category) ?? 0) + report.replaced)
|
|
}
|
|
|
|
console.log('\nگزارش تغییرها:')
|
|
for (const [category, count] of [...byCategory].sort((a, b) => b[1] - a[1])) {
|
|
console.log(` ${category.padEnd(12)} ${String(count).padStart(3)} مقدار رنگ`)
|
|
}
|
|
|
|
const untouched = reports.filter((report) => !report.replaced)
|
|
if (untouched.length) {
|
|
console.log(`\nلایه‌های بدون تغییر (${untouched.length}): ${untouched.map((report) => report.id).join(', ')}`)
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* دسترسی به MinIO (S3 Signature V4 — بدون وابستگی تازه) */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
type Credentials = { user: string; secret: string }
|
|
|
|
async function readCredentials(): Promise<Credentials> {
|
|
const envPath = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '.env')
|
|
const fromFile: Record<string, string> = {}
|
|
try {
|
|
for (const line of (await readFile(envPath, 'utf8')).split(/\r?\n/)) {
|
|
const match = line.match(/^([A-Z0-9_]+)=(.*)$/)
|
|
if (match) fromFile[match[1]] = match[2].trim()
|
|
}
|
|
} catch {
|
|
/* فایل .env اختیاری است — متغیرهای محیطی جایگزین می‌شوند */
|
|
}
|
|
|
|
const user = process.env.MINIO_ROOT_USER || fromFile.MINIO_ROOT_USER || 'aramesh'
|
|
const secret = process.env.MINIO_ROOT_PASSWORD || fromFile.MINIO_ROOT_PASSWORD
|
|
if (!secret) throw new Error('MINIO_ROOT_PASSWORD پیدا نشد (نه در .env و نه در متغیرهای محیطی)')
|
|
return { user, secret }
|
|
}
|
|
|
|
const sha256 = (value: string | Buffer) => createHash('sha256').update(value).digest('hex')
|
|
const hmac = (key: string | Buffer, value: string) => createHmac('sha256', key).update(value).digest()
|
|
const hmacHex = (key: Buffer, value: string) => createHmac('sha256', key).update(value).digest('hex')
|
|
|
|
/** PUT امضاشدهٔ S3 — همان چیزی که کنسول MinIO و پنل ادمین هم انجام می‌دهند */
|
|
async function putObject(endpoint: string, objectPath: string, body: string, credentials: Credentials): Promise<void> {
|
|
const url = new URL(objectPath, endpoint)
|
|
const amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '')
|
|
const dateStamp = amzDate.slice(0, 8)
|
|
const payloadHash = sha256(body)
|
|
const canonicalHeaders = `host:${url.host}\nx-amz-content-sha256:${payloadHash}\nx-amz-date:${amzDate}\n`
|
|
const signedHeaders = 'host;x-amz-content-sha256;x-amz-date'
|
|
const canonicalRequest = ['PUT', url.pathname, '', canonicalHeaders, signedHeaders, payloadHash].join('\n')
|
|
const scope = `${dateStamp}/us-east-1/s3/aws4_request`
|
|
const stringToSign = ['AWS4-HMAC-SHA256', amzDate, scope, sha256(canonicalRequest)].join('\n')
|
|
const signingKey = hmac(hmac(hmac(hmac(`AWS4${credentials.secret}`, dateStamp), 'us-east-1'), 's3'), 'aws4_request')
|
|
const authorization =
|
|
`AWS4-HMAC-SHA256 Credential=${credentials.user}/${scope}, ` +
|
|
`SignedHeaders=${signedHeaders}, Signature=${hmacHex(signingKey, stringToSign)}`
|
|
|
|
const response = await fetch(url, {
|
|
method: 'PUT',
|
|
headers: {
|
|
Authorization: authorization,
|
|
'x-amz-content-sha256': payloadHash,
|
|
'x-amz-date': amzDate,
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body,
|
|
})
|
|
if (!response.ok) throw new Error(`PUT ${objectPath} → HTTP ${response.status} ${await response.text()}`)
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ */
|
|
/* اجرا */
|
|
/* ------------------------------------------------------------------ */
|
|
|
|
const ENDPOINT = process.env.MAP_ENDPOINT ?? 'http://localhost:19000'
|
|
const STYLE_PATH = '/maps/style.json'
|
|
const BACKUP_PATH = '/maps/style.backup.json'
|
|
const OUTPUT_DIR = join(dirname(fileURLToPath(import.meta.url)), 'map-palette')
|
|
const LOCAL_BACKUP = join(OUTPUT_DIR, 'style.backup.json')
|
|
|
|
/** بازگردانی: پشتیبان دقیقاً به‌جای style.json نوشته می‌شود */
|
|
async function restore(): Promise<void> {
|
|
const backup = await readFile(LOCAL_BACKUP, 'utf8')
|
|
validateStyle(JSON.parse(backup) as StyleDocument, 'نسخهٔ پشتیبان')
|
|
await putObject(ENDPOINT, STYLE_PATH, backup, await readCredentials())
|
|
|
|
const restored = await (await fetch(new URL(STYLE_PATH, ENDPOINT))).text()
|
|
console.log(
|
|
restored === backup
|
|
? '✓ style.json دقیقاً به نسخهٔ پشتیبان برگشت'
|
|
: '✗ محتوای بازگردانده‌شده با پشتیبان یکسان نیست — دستی بررسی کنید',
|
|
)
|
|
}
|
|
|
|
const ACTIONS = ['--audit-fonts', '--fix-labels', '--fix-glyphs', '--palette', '--restore'] as const
|
|
|
|
async function main(): Promise<void> {
|
|
const dryRun = process.argv.includes('--dry-run')
|
|
const action = ACTIONS.find((flag) => process.argv.includes(flag))
|
|
|
|
// پیش‌فرض امن: بدون پرچم هیچ نوشتنی انجام نمی‌شود
|
|
if (!action) {
|
|
console.log(
|
|
'کاری انجام نشد — یکی از پرچم‌ها را بدهید:\n' +
|
|
' --audit-fonts گزارش پوشش خط‌های هر فونت در v2.0 (فقط خواندن)\n' +
|
|
' --fix-labels برچسب‌های دوزبانه + پشتهٔ فونت محلی\n' +
|
|
' --fix-glyphs اصلاح مسیر گلیف‌ها به v2.0\n' +
|
|
' --palette اعمال پالت تازه\n' +
|
|
' --restore بازگردانی از پشتیبان\n' +
|
|
' [--dry-run] فقط گزارش، بدون نوشتن روی MinIO',
|
|
)
|
|
return
|
|
}
|
|
|
|
if (action === '--audit-fonts') {
|
|
await auditFonts()
|
|
return
|
|
}
|
|
|
|
if (action === '--restore') {
|
|
await restore()
|
|
return
|
|
}
|
|
|
|
// ۱) خواندن سبک فعلی
|
|
const response = await fetch(new URL(STYLE_PATH, ENDPOINT))
|
|
if (!response.ok) throw new Error(`GET ${STYLE_PATH} → HTTP ${response.status}`)
|
|
const original = await response.text()
|
|
const style = JSON.parse(original) as StyleDocument
|
|
console.log(`سبک فعلی خوانده شد — ${(original.length / 1024).toFixed(1)} کیلوبایت`)
|
|
validateStyle(style, 'نسخهٔ فعلی')
|
|
|
|
// ۲) پشتیبان‌گیری، پیش از هر تغییر
|
|
await mkdir(OUTPUT_DIR, { recursive: true })
|
|
await writeFile(LOCAL_BACKUP, original, 'utf8')
|
|
console.log(`پشتیبان روی دیسک: scripts/map-palette/style.backup.json`)
|
|
if (!dryRun) {
|
|
await putObject(ENDPOINT, BACKUP_PATH, original, await readCredentials())
|
|
console.log(`پشتیبان روی MinIO: ${BACKUP_PATH}`)
|
|
}
|
|
|
|
// ۳) تغییر درخواستی، سپس اعتبارسنجی دوباره
|
|
if (action === '--fix-labels') {
|
|
const { changed, skipped } = fixLabels(style)
|
|
console.log(`\nلایه‌های برچسب اصلاح‌شده (${changed.length}):`)
|
|
for (const layer of changed) {
|
|
if (layer.field) console.log(` ${layer.id}\n متن: ${layer.field.from} → ${JSON.stringify(layer.field.to)}`)
|
|
console.log(` فونت: ${layer.font.from} → ${layer.font.to}`)
|
|
}
|
|
if (skipped.length) {
|
|
console.log(`\nلایه‌های بدون فیلد نام (فقط فونت اصلاح شد): ${skipped.join(', ')}`)
|
|
}
|
|
await verifyFonts(style)
|
|
} else if (action === '--fix-glyphs') {
|
|
const change = fixGlyphsPath(style)
|
|
console.log(
|
|
change ? `\nمسیر گلیف‌ها: ${change.from} → ${change.to}` : '\nمسیر گلیف‌ها از قبل به v2.0 اشاره می‌کند',
|
|
)
|
|
await verifyFonts(style)
|
|
} else {
|
|
reportPalette(recolorStyle(style))
|
|
}
|
|
validateStyle(style, 'نسخهٔ تازه')
|
|
|
|
// ۴) نوشتن و آپلود نسخهٔ تازه
|
|
const updated = JSON.stringify(style, null, 2)
|
|
await writeFile(join(OUTPUT_DIR, 'style.json'), updated, 'utf8')
|
|
if (dryRun) {
|
|
console.log('\nحالت آزمایشی — هیچ چیزی روی MinIO نوشته نشد.')
|
|
return
|
|
}
|
|
|
|
await putObject(ENDPOINT, STYLE_PATH, updated, await readCredentials())
|
|
console.log(`\nسبک تازه روی MinIO نوشته شد: ${STYLE_PATH}`)
|
|
}
|
|
|
|
main().catch((error: unknown) => {
|
|
console.error('\nخطا:', error instanceof Error ? error.message : error)
|
|
process.exitCode = 1
|
|
})
|