jtricerolph
8d688b459d
FastAPI backend (Python 3.11, MSSQL ODBC for SambaPOS, Azure DI OCR),
kitchen_db on central PG. React/TS/Vite frontend with navy sidebar layout.
Backend: auth.py (APP_SLUG=kitchen, SimpleNamespace — archive routes use
.kitchen_id/.is_admin without modification), main.py (51 migrations, scheduler,
internal router for KDS bookings feed), api/internal.py, full archive API
(31 routers: invoices, recipes, menus, sambapos, resos, newbook, disputes,
purchase_orders, etc.), models, migrations, OCR pipeline.
kitchen_id pinned to 1 (B1 — single hotel).
Frontend: AuthGate (app=kitchen, token shim for archive compat — B5b pending),
Layout (navy sidebar, 6 sections, Lucide icons, teal --app-primary),
App.tsx (Outlet pattern, UploadApp outside Layout), index.css (full :root block).
strict: false — archive components have type issues; build clean.
Note: 45 archive components call fetch('/api/...') without /kitchen/ prefix
(B5b). Runtime 404s; deferred until after initial testing.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
105 lines
3 KiB
JavaScript
105 lines
3 KiB
JavaScript
/**
|
|
* Estimate decoded byte length of a data:// URL *without* allocating large buffers.
|
|
* - For base64: compute exact decoded size using length and padding;
|
|
* handle %XX at the character-count level (no string allocation).
|
|
* - For non-base64: compute the exact percent-decoded UTF-8 byte length.
|
|
*
|
|
* @param {string} url
|
|
* @returns {number}
|
|
*/
|
|
const isHexDigit = (charCode) =>
|
|
(charCode >= 48 && charCode <= 57) ||
|
|
(charCode >= 65 && charCode <= 70) ||
|
|
(charCode >= 97 && charCode <= 102);
|
|
|
|
const isPercentEncodedByte = (str, i, len) =>
|
|
i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
|
|
|
|
export default function estimateDataURLDecodedBytes(url) {
|
|
if (!url || typeof url !== 'string') return 0;
|
|
if (!url.startsWith('data:')) return 0;
|
|
|
|
const comma = url.indexOf(',');
|
|
if (comma < 0) return 0;
|
|
|
|
const meta = url.slice(5, comma);
|
|
const body = url.slice(comma + 1);
|
|
const isBase64 = /;base64/i.test(meta);
|
|
|
|
if (isBase64) {
|
|
let effectiveLen = body.length;
|
|
const len = body.length; // cache length
|
|
|
|
for (let i = 0; i < len; i++) {
|
|
if (body.charCodeAt(i) === 37 /* '%' */ && i + 2 < len) {
|
|
const a = body.charCodeAt(i + 1);
|
|
const b = body.charCodeAt(i + 2);
|
|
const isHex = isHexDigit(a) && isHexDigit(b);
|
|
|
|
if (isHex) {
|
|
effectiveLen -= 2;
|
|
i += 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
let pad = 0;
|
|
let idx = len - 1;
|
|
|
|
const tailIsPct3D = (j) =>
|
|
j >= 2 &&
|
|
body.charCodeAt(j - 2) === 37 && // '%'
|
|
body.charCodeAt(j - 1) === 51 && // '3'
|
|
(body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100); // 'D' or 'd'
|
|
|
|
if (idx >= 0) {
|
|
if (body.charCodeAt(idx) === 61 /* '=' */) {
|
|
pad++;
|
|
idx--;
|
|
} else if (tailIsPct3D(idx)) {
|
|
pad++;
|
|
idx -= 3;
|
|
}
|
|
}
|
|
|
|
if (pad === 1 && idx >= 0) {
|
|
if (body.charCodeAt(idx) === 61 /* '=' */) {
|
|
pad++;
|
|
} else if (tailIsPct3D(idx)) {
|
|
pad++;
|
|
}
|
|
}
|
|
|
|
const groups = Math.floor(effectiveLen / 4);
|
|
const bytes = groups * 3 - (pad || 0);
|
|
return bytes > 0 ? bytes : 0;
|
|
}
|
|
|
|
// Compute UTF-8 byte length directly from UTF-16 code units without allocating
|
|
// a byte buffer (TextEncoder.encode would defeat the DoS guard on large bodies).
|
|
// Valid %XX triplets count as one decoded byte; this matches the bytes that
|
|
// decodeURIComponent(body) would produce before Buffer re-encodes the string.
|
|
let bytes = 0;
|
|
for (let i = 0, len = body.length; i < len; i++) {
|
|
const c = body.charCodeAt(i);
|
|
if (c === 37 /* '%' */ && isPercentEncodedByte(body, i, len)) {
|
|
bytes += 1;
|
|
i += 2;
|
|
} else if (c < 0x80) {
|
|
bytes += 1;
|
|
} else if (c < 0x800) {
|
|
bytes += 2;
|
|
} else if (c >= 0xd800 && c <= 0xdbff && i + 1 < len) {
|
|
const next = body.charCodeAt(i + 1);
|
|
if (next >= 0xdc00 && next <= 0xdfff) {
|
|
bytes += 4;
|
|
i++;
|
|
} else {
|
|
bytes += 3;
|
|
}
|
|
} else {
|
|
bytes += 3;
|
|
}
|
|
}
|
|
return bytes;
|
|
}
|