@stisocial/ui 0.2.1 → 0.3.0

package/dist/components/QrCode/qr.js

@@ -0,0 +1,669 @@
+// src/components/QrCode/qr.ts
+const ECL_INDEX = {
+	L: 0,
+	M: 1,
+	Q: 2,
+	H: 3
+};
+/** Biçim bitlerindeki hata düzeltme kodu. */
+const ECL_FORMAT = {
+	L: 1,
+	M: 0,
+	Q: 3,
+	H: 2
+};
+const ECC_CODEWORDS_PER_BLOCK = [
+	[
+		-1,
+		7,
+		10,
+		15,
+		20,
+		26,
+		18,
+		20,
+		24,
+		30,
+		18,
+		20,
+		24,
+		26,
+		30,
+		22,
+		24,
+		28,
+		30,
+		28,
+		28,
+		28,
+		28,
+		30,
+		30,
+		26,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	[
+		-1,
+		10,
+		16,
+		26,
+		18,
+		24,
+		16,
+		18,
+		22,
+		22,
+		26,
+		30,
+		22,
+		22,
+		24,
+		24,
+		28,
+		28,
+		26,
+		26,
+		26,
+		26,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28
+	],
+	[
+		-1,
+		13,
+		22,
+		18,
+		26,
+		18,
+		24,
+		18,
+		22,
+		20,
+		24,
+		28,
+		26,
+		24,
+		20,
+		30,
+		24,
+		28,
+		28,
+		26,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	[
+		-1,
+		17,
+		28,
+		22,
+		16,
+		22,
+		28,
+		26,
+		26,
+		24,
+		28,
+		24,
+		28,
+		22,
+		24,
+		24,
+		30,
+		28,
+		28,
+		26,
+		28,
+		30,
+		24,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	]
+];
+const NUM_ERROR_CORRECTION_BLOCKS = [
+	[
+		-1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		2,
+		2,
+		4,
+		4,
+		4,
+		4,
+		4,
+		6,
+		6,
+		6,
+		6,
+		7,
+		8,
+		8,
+		9,
+		9,
+		10,
+		12,
+		12,
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19,
+		19,
+		20,
+		21,
+		22,
+		24,
+		25
+	],
+	[
+		-1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		4,
+		5,
+		5,
+		5,
+		8,
+		9,
+		9,
+		10,
+		10,
+		11,
+		13,
+		14,
+		16,
+		17,
+		17,
+		18,
+		20,
+		21,
+		23,
+		25,
+		26,
+		28,
+		29,
+		31,
+		33,
+		35,
+		37,
+		38,
+		40,
+		43,
+		45,
+		47,
+		49
+	],
+	[
+		-1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		6,
+		6,
+		8,
+		8,
+		8,
+		10,
+		12,
+		16,
+		12,
+		17,
+		16,
+		18,
+		21,
+		20,
+		23,
+		23,
+		25,
+		27,
+		29,
+		34,
+		34,
+		35,
+		38,
+		40,
+		43,
+		45,
+		48,
+		51,
+		53,
+		56,
+		59,
+		62,
+		65,
+		68
+	],
+	[
+		-1,
+		1,
+		1,
+		2,
+		4,
+		4,
+		4,
+		5,
+		6,
+		8,
+		8,
+		11,
+		11,
+		16,
+		16,
+		18,
+		16,
+		19,
+		21,
+		25,
+		25,
+		25,
+		34,
+		30,
+		32,
+		35,
+		37,
+		40,
+		42,
+		45,
+		48,
+		51,
+		54,
+		57,
+		60,
+		63,
+		66,
+		70,
+		74,
+		77,
+		81
+	]
+];
+const PENALTY_N1 = 3;
+const PENALTY_N2 = 3;
+const PENALTY_N3 = 40;
+const PENALTY_N4 = 10;
+const bit = (x, i) => (x >>> i & 1) !== 0;
+/** Sürümün veri ve hata düzeltme için kullanılabilir modül sayısı. */
+function rawDataModules(ver) {
+	let result = (16 * ver + 128) * ver + 64;
+	if (ver >= 2) {
+		const numAlign = Math.floor(ver / 7) + 2;
+		result -= (25 * numAlign - 10) * numAlign - 55;
+		if (ver >= 7) result -= 36;
+	}
+	return result;
+}
+const eccPerBlock = (ver, ecl) => ECC_CODEWORDS_PER_BLOCK[ECL_INDEX[ecl]]?.[ver];
+const numBlocks = (ver, ecl) => NUM_ERROR_CORRECTION_BLOCKS[ECL_INDEX[ecl]]?.[ver];
+function dataCodewords(ver, ecl) {
+	return Math.floor(rawDataModules(ver) / 8) - eccPerBlock(ver, ecl) * numBlocks(ver, ecl);
+}
+function gfMultiply(x, y) {
+	let z = 0;
+	for (let i = 7; i >= 0; i--) {
+		z = z << 1 ^ (z >>> 7) * 285;
+		z ^= (y >>> i & 1) * x;
+	}
+	return z;
+}
+function rsDivisor(degree) {
+	const result = new Array(degree).fill(0);
+	result[degree - 1] = 1;
+	let root = 1;
+	for (let i = 0; i < degree; i++) {
+		for (let j = 0; j < result.length; j++) {
+			result[j] = gfMultiply(result[j], root);
+			if (j + 1 < result.length) result[j] = result[j] ^ result[j + 1];
+		}
+		root = gfMultiply(root, 2);
+	}
+	return result;
+}
+function rsRemainder(data, divisor) {
+	const result = new Array(divisor.length).fill(0);
+	for (const b of data) {
+		const factor = b ^ result.shift();
+		result.push(0);
+		divisor.forEach((coef, i) => {
+			result[i] = result[i] ^ gfMultiply(coef, factor);
+		});
+	}
+	return result;
+}
+/** Bayt verisini QR modül matrisine çevirir. Veri en büyük sürüme sığmazsa hata fırlatır. */
+function encodeQr(bytes, ecl = "M") {
+	let version = 1;
+	let capacityBits = 0;
+	for (;; version++) {
+		if (version > 40) throw new RangeError("Veri QR koduna sığmıyor");
+		capacityBits = dataCodewords(version, ecl) * 8;
+		if (4 + (version <= 9 ? 8 : 16) + bytes.length * 8 <= capacityBits) break;
+	}
+	const bits = [];
+	const append = (value, length) => {
+		for (let i = length - 1; i >= 0; i--) bits.push(value >>> i & 1);
+	};
+	append(4, 4);
+	append(bytes.length, version <= 9 ? 8 : 16);
+	for (const b of bytes) append(b, 8);
+	append(0, Math.min(4, capacityBits - bits.length));
+	append(0, (8 - bits.length % 8) % 8);
+	for (let pad = 236; bits.length < capacityBits; pad ^= 253) append(pad, 8);
+	const data = [];
+	for (let i = 0; i < bits.length; i += 8) {
+		let byte = 0;
+		for (let j = 0; j < 8; j++) byte = byte << 1 | bits[i + j];
+		data.push(byte);
+	}
+	const blocks = numBlocks(version, ecl);
+	const blockEcc = eccPerBlock(version, ecl);
+	const rawCodewords = Math.floor(rawDataModules(version) / 8);
+	const shortBlocks = blocks - rawCodewords % blocks;
+	const shortBlockLen = Math.floor(rawCodewords / blocks);
+	const divisor = rsDivisor(blockEcc);
+	const parts = [];
+	for (let i = 0, k = 0; i < blocks; i++) {
+		const dat = data.slice(k, k + shortBlockLen - blockEcc + (i < shortBlocks ? 0 : 1));
+		k += dat.length;
+		const ecc = rsRemainder(dat, divisor);
+		if (i < shortBlocks) dat.push(0);
+		parts.push(dat.concat(ecc));
+	}
+	const codewords = [];
+	for (let i = 0; i < parts[0].length; i++) parts.forEach((block, j) => {
+		if (i !== shortBlockLen - blockEcc || j >= shortBlocks) codewords.push(block[i]);
+	});
+	const size = version * 4 + 17;
+	const modules = Array.from({ length: size }, () => new Array(size).fill(false));
+	const isFunction = Array.from({ length: size }, () => new Array(size).fill(false));
+	const setFunction = (x, y, dark) => {
+		modules[y][x] = dark;
+		isFunction[y][x] = true;
+	};
+	for (let i = 0; i < size; i++) {
+		setFunction(6, i, i % 2 === 0);
+		setFunction(i, 6, i % 2 === 0);
+	}
+	const finder = (cx, cy) => {
+		for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
+			const dist = Math.max(Math.abs(dx), Math.abs(dy));
+			const x = cx + dx;
+			const y = cy + dy;
+			if (x >= 0 && x < size && y >= 0 && y < size) setFunction(x, y, dist !== 2 && dist !== 4);
+		}
+	};
+	finder(3, 3);
+	finder(size - 4, 3);
+	finder(3, size - 4);
+	const alignPositions = [];
+	if (version > 1) {
+		const numAlign = Math.floor(version / 7) + 2;
+		const step = version === 32 ? 26 : Math.ceil((version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+		alignPositions.push(6);
+		for (let pos = size - 7; alignPositions.length < numAlign; pos -= step) alignPositions.splice(1, 0, pos);
+	}
+	const last = alignPositions.length - 1;
+	alignPositions.forEach((ax, i) => {
+		alignPositions.forEach((ay, j) => {
+			if (i === 0 && j === 0 || i === 0 && j === last || i === last && j === 0) return;
+			for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) setFunction(ax + dx, ay + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+		});
+	});
+	const drawFormat = (mask) => {
+		const value = ECL_FORMAT[ecl] << 3 | mask;
+		let rem = value;
+		for (let i = 0; i < 10; i++) rem = rem << 1 ^ (rem >>> 9) * 1335;
+		const fb = (value << 10 | rem) ^ 21522;
+		for (let i = 0; i <= 5; i++) setFunction(8, i, bit(fb, i));
+		setFunction(8, 7, bit(fb, 6));
+		setFunction(8, 8, bit(fb, 7));
+		setFunction(7, 8, bit(fb, 8));
+		for (let i = 9; i < 15; i++) setFunction(14 - i, 8, bit(fb, i));
+		for (let i = 0; i < 8; i++) setFunction(size - 1 - i, 8, bit(fb, i));
+		for (let i = 8; i < 15; i++) setFunction(8, size - 15 + i, bit(fb, i));
+		setFunction(8, size - 8, true);
+	};
+	drawFormat(0);
+	if (version >= 7) {
+		let rem = version;
+		for (let i = 0; i < 12; i++) rem = rem << 1 ^ (rem >>> 11) * 7973;
+		const vb = version << 12 | rem;
+		for (let i = 0; i < 18; i++) {
+			const dark = bit(vb, i);
+			const a = size - 11 + i % 3;
+			const b = Math.floor(i / 3);
+			setFunction(a, b, dark);
+			setFunction(b, a, dark);
+		}
+	}
+	let i = 0;
+	for (let right = size - 1; right >= 1; right -= 2) {
+		if (right === 6) right = 5;
+		for (let vert = 0; vert < size; vert++) for (let j = 0; j < 2; j++) {
+			const x = right - j;
+			const y = (right + 1 & 2) === 0 ? size - 1 - vert : vert;
+			if (!isFunction[y][x] && i < codewords.length * 8) {
+				modules[y][x] = bit(codewords[i >>> 3], 7 - (i & 7));
+				i++;
+			}
+		}
+	}
+	const applyMask = (mask) => {
+		for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+			let invert;
+			switch (mask) {
+				case 0:
+					invert = (x + y) % 2 === 0;
+					break;
+				case 1:
+					invert = y % 2 === 0;
+					break;
+				case 2:
+					invert = x % 3 === 0;
+					break;
+				case 3:
+					invert = (x + y) % 3 === 0;
+					break;
+				case 4:
+					invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+					break;
+				case 5:
+					invert = x * y % 2 + x * y % 3 === 0;
+					break;
+				case 6:
+					invert = (x * y % 2 + x * y % 3) % 2 === 0;
+					break;
+				default: invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
+			}
+			if (!isFunction[y][x] && invert) modules[y][x] = !modules[y][x];
+		}
+	};
+	const addHistory = (length, history) => {
+		const run = history[0] === 0 ? length + size : length;
+		history.pop();
+		history.unshift(run);
+	};
+	const countPatterns = (h) => {
+		const n = h[1];
+		const core = n > 0 && h[2] === n && h[3] === n * 3 && h[4] === n && h[5] === n;
+		return (core && h[0] >= n * 4 && h[6] >= n ? 1 : 0) + (core && h[6] >= n * 4 && h[0] >= n ? 1 : 0);
+	};
+	const terminate = (color, length, history) => {
+		let run = length;
+		if (color) {
+			addHistory(run, history);
+			run = 0;
+		}
+		run += size;
+		addHistory(run, history);
+		return countPatterns(history);
+	};
+	const penalty = () => {
+		let result = 0;
+		for (const axis of [0, 1]) for (let a = 0; a < size; a++) {
+			let color = false;
+			let run = 0;
+			const history = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let b = 0; b < size; b++) {
+				const dark = axis === 0 ? modules[a][b] : modules[b][a];
+				if (dark === color) {
+					run++;
+					if (run === 5) result += PENALTY_N1;
+					else if (run > 5) result++;
+				} else {
+					addHistory(run, history);
+					if (!color) result += countPatterns(history) * PENALTY_N3;
+					color = dark;
+					run = 1;
+				}
+			}
+			result += terminate(color, run, history) * PENALTY_N3;
+		}
+		for (let y = 0; y < size - 1; y++) for (let x = 0; x < size - 1; x++) {
+			const c = modules[y][x];
+			if (c === modules[y][x + 1] && c === modules[y + 1][x] && c === modules[y + 1][x + 1]) result += PENALTY_N2;
+		}
+		let dark = 0;
+		for (const row of modules) for (const m of row) if (m) dark++;
+		const total = size * size;
+		const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+		result += k * PENALTY_N4;
+		return result;
+	};
+	let best = 0;
+	let minPenalty = Number.POSITIVE_INFINITY;
+	for (let mask = 0; mask < 8; mask++) {
+		applyMask(mask);
+		drawFormat(mask);
+		const p = penalty();
+		if (p < minPenalty) {
+			best = mask;
+			minPenalty = p;
+		}
+		applyMask(mask);
+	}
+	applyMask(best);
+	drawFormat(best);
+	return {
+		version,
+		size,
+		mask: best,
+		modules
+	};
+}
+/** Metni UTF-8 baytlarına çevirip kodlar. */
+function encodeQrText(text, ecl = "M") {
+	return encodeQr(new TextEncoder().encode(text), ecl);
+}
+/**
+* Koyu modülleri tek SVG yoluna çevirir (yatay ardışık modüller tek dikdörtgen): `margin` modül
+* kadar boşluk bırakılır. Sonuç `viewBox` ile birlikte kullanılır.
+*/
+function qrPath(matrix, margin = 4) {
+	const parts = [];
+	matrix.modules.forEach((row, y) => {
+		let x = 0;
+		while (x < row.length) {
+			if (!row[x]) {
+				x++;
+				continue;
+			}
+			let end = x;
+			while (end < row.length && row[end]) end++;
+			parts.push(`M${x + margin} ${y + margin}h${end - x}v1h${x - end}z`);
+			x = end;
+		}
+	});
+	return parts.join("");
+}
+export { encodeQr, encodeQrText, qrPath };

package/dist/components/QuoteTemplate/QuoteTemplate.css

@@ -0,0 +1,81 @@
+@layer sti.reset, sti.tokens, sti.base, sti.components, sti.variants, sti.utilities;
+@layer sti.components {
+  .sti-QuoteTemplate-section-48886 {
+    gap: var(--sti-space-3);
+    break-inside: avoid-page;
+    display: grid;
+  }
+
+  .sti-QuoteTemplate-sectionTitle-60520 {
+    font-size: var(--sti-font-size-md);
+    font-weight: var(--sti-font-weight-semibold);
+    margin: 0;
+  }
+
+  .sti-QuoteTemplate-text-214ce {
+    max-inline-size: 48rem;
+    color: var(--sti-fg);
+    margin: 0;
+  }
+
+  .sti-QuoteTemplate-muted-ef5f8 {
+    color: var(--sti-fg-muted);
+    font-size: var(--sti-font-size-sm);
+    margin: 0;
+  }
+
+  .sti-QuoteTemplate-totals-6ca55 {
+    justify-items: end;
+    display: grid;
+  }
+
+  .sti-QuoteTemplate-totals-6ca55 > * {
+    inline-size: 100%;
+    max-inline-size: 22rem;
+  }
+
+  .sti-QuoteTemplate-split-9f172 {
+    align-items: start;
+    gap: var(--sti-space-6);
+    grid-template-columns: repeat(auto-fit, minmax(min(100%, 16rem), 1fr));
+    display: grid;
+  }
+
+  .sti-QuoteTemplate-terms-1f808 {
+    gap: var(--sti-space-1);
+    margin: 0;
+    padding-inline-start: var(--sti-space-5);
+    display: grid;
+  }
+
+  .sti-QuoteTemplate-figures-447c1 {
+    gap: var(--sti-space-3);
+    grid-template-columns: repeat(auto-fit, minmax(min(100%, 9rem), 1fr));
+    margin: 0;
+    display: grid;
+  }
+
+  .sti-QuoteTemplate-figure-d5a99 {
+    padding: var(--sti-space-3) var(--sti-space-4);
+    border: var(--sti-border-width) solid var(--sti-border-subtle);
+    border-radius: var(--sti-radius-sm);
+    background: var(--sti-bg-subtle);
+    flex-direction: column;
+    display: flex;
+  }
+
+  .sti-QuoteTemplate-figure-d5a99 > dt {
+    color: var(--sti-fg-muted);
+    font-size: var(--sti-font-size-sm);
+    order: 2;
+  }
+
+  .sti-QuoteTemplate-figure-d5a99 > dd {
+    font-family: var(--sti-font-display);
+    font-size: var(--sti-font-size-xl);
+    font-weight: var(--sti-font-weight-bold);
+    font-variant-numeric: tabular-nums;
+    order: 1;
+    margin: 0;
+  }
+}