@flickfyi/flkr 0.0.141 → 0.0.146

package/node_modules/@flickfyi/core/tests/kowalski-calculator.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+	calculatorDisplay,
+	calculatorEquation,
+	type CalculatorKey,
+	calculatorKeyLabel,
+	initialCalculator,
+	pressCalculatorKey,
+} from '~/kowalski/calculator'
+import { kowalskiCatalog } from '~/kowalski/catalog'
+
+describe('Kowalski calculator keypad', () => {
+	it.each([
+		['1234.00', '1,234.00'],
+		['1234.', '1,234.'],
+		['-0.0', '-0.0'],
+		['1e-10', '0.0000000001'],
+		['1e+12', '1E12'],
+		['1e-14', '1E-14'],
+		['Error', 'Error'],
+	])('formats %s as %s without changing the canonical entry', (entry, expected) => {
+		expect(calculatorDisplay(entry)).toBe(expected)
+	})
+	it('seeds the authored calculation and repeats its last operation', () => {
+		const initial = initialCalculator({ left: 24, operator: '*', right: 7 })
+		expect(initial.entry).toBe('168')
+		expect(calculatorEquation(initial)).toBe('24 × 7 =')
+		expect(pressCalculatorKey(initial, '=').entry).toBe('1176')
+	})
+	it('replaces a result with a fresh entry, keeps decimal drafts, and ignores a second decimal', () => {
+		const draft = enter('clear', '0', '0', '.', '0', '5', '.')
+		expect(draft.entry).toBe('0.05')
+		expect(enter('2', '+', '3', '=', '4', '.', '0').entry).toBe('4.0')
+		expect(enter('.', '1', '+', '.', '2', '=').entry).toBe('0.3')
+	})
+	it('chains operations left to right and replaces an operator before the next number', () => {
+		expect(enter('2', '+', '3', '*', '4', '=').entry).toBe('20')
+		expect(enter('8', '+', '-', '3', '=').entry).toBe('5')
+		expect(enter('2', '+', '=', '=').entry).toBe('6')
+	})
+	it('clears the current entry before clearing the full calculation', () => {
+		const partial = enter('8', '+', '3')
+		expect(calculatorKeyLabel(partial, 'clear')).toBe('C')
+		const cleared = pressCalculatorKey(partial, 'clear')
+		expect(cleared).toMatchObject({ entry: '0', left: 8, phase: 'right' })
+		expect(calculatorKeyLabel(cleared, 'clear')).toBe('AC')
+		expect(pressCalculatorKey(cleared, '=').entry).toBe('8')
+		expect(pressCalculatorKey(cleared, 'clear')).toMatchObject({
+			entry: '0',
+			left: 0,
+			phase: 'left',
+			right: 0,
+		})
+	})
+	it('negates an entry and applies contextual percentages', () => {
+		expect(enter('5', 'sign', '+', '2', '=').entry).toBe('-3')
+		expect(enter('2', '*', 'sign', '3', '=').entry).toBe('-6')
+		expect(enter('2', '0', '0', '+', '1', '0', '%', '=').entry).toBe('220')
+		expect(enter('2', '0', '0', '-', '1', '0', '%', '=').entry).toBe('180')
+		expect(enter('2', '0', '0', '*', '1', '0', '%', '=').entry).toBe('20')
+		expect(enter('2', '0', '0', '/', '1', '0', '%', '=').entry).toBe('2000')
+		expect(enter('5', '%').entry).toBe('0.05')
+		expect(enter('2', '0', '0', '+', '1', '0', '%', '5', '=').entry).toBe('205')
+		expect(enter('5', '/', '2', '=', 'sign', '7').entry).toBe('7')
+		expect(enter('0', '.', '0', '0', '0', '0', '0', '1', '%', '7').entry).toBe('7')
+	})
+	it('shows an error for division by zero and accepts a new calculation immediately', () => {
+		const error = enter('4', '/', '0', '=')
+		expect(error).toMatchObject({ entry: 'Error', phase: 'error' })
+		expect(calculatorEquation(error)).toBe('4 ÷ 0 =')
+		expect(pressCalculatorKey(error, '7')).toMatchObject({ entry: '7', phase: 'left' })
+		expect(pressCalculatorKey(error, 'clear')).toMatchObject({
+			entry: '0',
+			phase: 'left',
+		})
+		expect(initialCalculator({ left: 1e308, operator: '*', right: 1e308 }).entry).toBe(
+			'Error'
+		)
+	})
+	it('retains a pending decimal entry and repeated equals through schema serialization', () => {
+		const calculation = enter('1', '2', '+', '3', '.')
+		const reopened = kowalskiCatalog.calculator.storeSchema.parse(
+			JSON.parse(JSON.stringify({ calculation }))
+		).calculation
+		expect(reopened).toEqual(calculation)
+		expect(pressCalculatorKey(reopened, '5').entry).toBe('3.5')
+		expect(pressCalculatorKey(reopened, '=').entry).toBe('15')
+		expect(pressCalculatorKey(pressCalculatorKey(reopened, '='), '=').entry).toBe('18')
+	})
+	it('backspaces decimal and negative drafts without losing the pending calculation', () => {
+		expect(enter('1', '2', '.', '3', 'backspace').entry).toBe('12.')
+		expect(enter('1', '2', '.', 'backspace').entry).toBe('12')
+		expect(enter('5', 'sign', 'backspace').entry).toBe('0')
+		expect(enter('0', 'backspace').entry).toBe('0')
+		const calculation = enter('1', '2', '+', '3', '.', '5', 'backspace')
+		const reopened = kowalskiCatalog.calculator.storeSchema.parse(
+			JSON.parse(JSON.stringify({ calculation }))
+		).calculation
+		expect(reopened).toMatchObject({ entry: '3.', left: 12, phase: 'right' })
+		expect(calculatorKeyLabel(reopened, 'backspace')).toBe('⌫')
+		const result = pressCalculatorKey(pressCalculatorKey(reopened, '7'), '=')
+		expect(result.entry).toBe('15.7')
+		expect(pressCalculatorKey(result, '=').entry).toBe('19.4')
+	})
+	it('backspaces a pending operand to zero and clears completed or failed calculations', () => {
+		expect(enter('8', '+', 'backspace', '=').entry).toBe('8')
+		for (const calculation of [enter('8', '+', '2', '='), enter('4', '/', '0', '=')]) {
+			const cleared = pressCalculatorKey(calculation, 'backspace')
+			expect(cleared).toMatchObject({ entry: '0', left: 0, phase: 'left', right: 0 })
+			expect(pressCalculatorKey(cleared, '=')).toEqual(cleared)
+			expect(pressCalculatorKey(cleared, '7').entry).toBe('7')
+		}
+	})
+	it('rejects malformed persisted calculator entries before keypad evaluation', () => {
+		const schema = kowalskiCatalog.calculator.storeSchema
+		const calculation = initialCalculator({ left: 1, operator: '+', right: 2 })
+		for (const entry of ['Error', '1e999']) {
+			expect(schema.safeParse({ calculation: { ...calculation, entry } }).success).toBe(
+				false
+			)
+		}
+		expect(
+			schema.safeParse({ calculation: { ...calculation, phase: 'error' } }).success
+		).toBe(false)
+	})
+	it('caps typed entries while preserving small authored values', () => {
+		expect(
+			enter('1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3').entry
+		).toBe('123456789012')
+		expect(initialCalculator({ left: 0.0001, operator: '+', right: 0 }).entry).toBe(
+			'0.0001'
+		)
+	})
+})
+
+function enter(...keys: CalculatorKey[]) {
+	return keys.reduce(
+		(state, key) => pressCalculatorKey(state, key),
+		pressCalculatorKey(initialCalculator({ left: 0, operator: '+', right: 0 }), 'clear')
+	)
+}

package/node_modules/@flickfyi/core/tests/kowalski-contracts.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod/v4'
+
+import { kowalskiCatalog } from '~/kowalski/catalog'
+
+describe('Kowalski component contracts', () => {
+	it('rejects unsupported and missing item IDs', () => {
+		expect(
+			kowalskiCatalog.checklist.props.safeParse({
+				items: [{ id: '__proto__', label: 'A' }],
+				title: 'Packing',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.checklist.props.safeParse({
+				items: [{ id: 'item-1', label: 'A' }, { label: 'B' }],
+				title: 'Packing',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.poll.props.safeParse({
+				options: [{ id: 'option-1', label: 'A' }, { label: 'B' }],
+				question: 'Lunch?',
+			}).success
+		).toBe(false)
+	})
+	it('defines the complete 27-feature collection with standard serializable stores', () => {
+		expect(Object.keys(kowalskiCatalog).toSorted()).toEqual([
+			'billSplit',
+			'bookmark',
+			'budget',
+			'calculator',
+			'checklist',
+			'colorPalette',
+			'contact',
+			'countdown',
+			'event',
+			'expense',
+			'goal',
+			'habit',
+			'ledger',
+			'note',
+			'poll',
+			'randomPicker',
+			'rating',
+			'recipe',
+			'reminder',
+			'rotation',
+			'scoreboard',
+			'shoppingList',
+			'taskBoard',
+			'timeZone',
+			'timer',
+			'trip',
+			'unitConverter',
+		])
+		for (const entry of Object.values(kowalskiCatalog)) {
+			const json = z.toJSONSchema(entry.storeSchema, { target: 'draft-7' })
+			const restored = z.fromJSONSchema(json)
+			const state = entry.storeSchema.parse({})
+			expect(restored.parse(state)).toEqual(state)
+			expect(JSON.parse(JSON.stringify(state))).toEqual(state)
+		}
+	})
+
+	it('uses default bindings unless an optional feature ID is supplied', () => {
+		const input = {
+			items: [
+				{ id: 'tent', label: 'Tent' },
+				{ id: 'tent-poles', label: 'Tent' },
+			],
+			title: 'Packing',
+		}
+		const props = kowalskiCatalog.checklist.props.parse(input)
+		expect(props.items).toEqual(input.items)
+		expect(props.id).toBeUndefined()
+		expect(props.revision).toBe(0)
+		expect(props.scope).toBe('private')
+		expect(
+			kowalskiCatalog.checklist.props.safeParse({
+				...input,
+				instanceId: 'caller-plumbing',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.checklist.props.parse({
+				...input,
+				id: 'Packing2',
+				revision: 2,
+				scope: 'public',
+			})
+		).toMatchObject({ id: 'Packing2', revision: 2, scope: 'public' })
+		for (const id of ['', '2Packing', 'packing-list', 'packing list', '__proto__']) {
+			expect(kowalskiCatalog.checklist.props.safeParse({ ...input, id }).success).toBe(
+				false
+			)
+		}
+		for (const revision of [-1, 0.5]) {
+			expect(
+				kowalskiCatalog.checklist.props.safeParse({ ...input, revision }).success
+			).toBe(false)
+		}
+	})
+
+	it.each([
+		{ input: { people: 2, total: 10 }, schema: kowalskiCatalog.billSplit.props },
+		{ input: { amount: 10, title: 'Lunch' }, schema: kowalskiCatalog.expense.props },
+	])('defaults money to USD and accepts explicit currencies (%#)', ({ input, schema }) => {
+		expect(schema.parse(input).currency).toBe('USD')
+		expect(schema.parse({ ...input, currency: 'JPY' }).currency).toBe('JPY')
+	})
+
+	it('rejects incompatible unit conversions instead of rendering an invented answer', () => {
+		expect(
+			kowalskiCatalog.unitConverter.props.safeParse({
+				from: 'km',
+				to: 'kg',
+				value: 12,
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.unitConverter.props.safeParse({
+				from: 'km',
+				to: 'mi',
+				value: 12,
+			}).success
+		).toBe(true)
+	})
+
+	it('rejects unsafe links, non-finite amounts, reversed trips, and invalid instants', () => {
+		for (const url of [
+			'https://?',
+			'https://',
+			'javascript:alert(1)',
+			'https://999.999.999.999',
+		]) {
+			expect(
+				kowalskiCatalog.bookmark.props.safeParse({ title: 'Link', url }).success
+			).toBe(false)
+			expect(
+				kowalskiCatalog.bookmark.storeSchema.safeParse({ url: { value: url } }).success
+			).toBe(false)
+		}
+		expect(
+			kowalskiCatalog.bookmark.props.safeParse({
+				title: 'Run code',
+				url: 'javascript:alert(1)',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.billSplit.props.safeParse({
+				currency: 'USD',
+				people: 2,
+				total: Infinity,
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.trip.props.safeParse({
+				destination: 'Rome',
+				endDate: '2026-10-20',
+				origin: 'Paris',
+				startDate: '2026-10-25',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.countdown.props.safeParse({
+				target: 'tomorrow',
+				title: 'Launch',
+			}).success
+		).toBe(false)
+	})
+
+	it('validates durable values against the authored field constraints', () => {
+		expect(
+			kowalskiCatalog.unitConverter.storeSchema.safeParse({
+				from: { value: 'km' },
+				to: { value: 'kg' },
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.countdown.storeSchema.safeParse({ target: { value: 'tomorrow' } })
+				.success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.colorPalette.storeSchema.safeParse({ color: { value: 'blueish' } })
+				.success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.trip.storeSchema.safeParse({
+				endDate: { value: '2026-10-20' },
+				startDate: { value: '2026-10-25' },
+			}).success
+		).toBe(false)
+	})
+
+	it('bounds random choices and arithmetic without accepting executable expressions', () => {
+		expect(
+			kowalskiCatalog.randomPicker.props.safeParse({
+				maximum: 2,
+				minimum: 10,
+				mode: 'range',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.randomPicker.props.safeParse({
+				mode: 'list',
+				options: [],
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.calculator.props.safeParse({
+				expression: 'globalThis.secret()',
+			}).success
+		).toBe(false)
+		expect(
+			kowalskiCatalog.calculator.props.safeParse({
+				left: 12,
+				operator: '*',
+				right: 7,
+			}).success
+		).toBe(true)
+	})
+})