@rokkit/forms 1.0.0-next.122

package/src/lib/deprecated/nested.spec.js

@@ -0,0 +1,512 @@
+import { describe, it, expect } from 'vitest'
+
+import { deriveNestedSchema, flattenElement, generateTreeTable, generateIndex } from './nested'
+
+describe('nested', () => {
+	describe('flattenElement', () => {
+		it('should flatten an element', () => {
+			const input = {
+				key: 'test',
+				value: 'test',
+				type: 'string',
+				scope: '#/test'
+			}
+			const result = flattenElement(input)
+			expect(result).toEqual({
+				[input.scope]: input
+			})
+		})
+
+		it('should flatten an array element', () => {
+			const input = {
+				key: 'test',
+				value: ['red', 'blue', 'green'],
+				type: 'array',
+				scope: '#/test'
+			}
+			const result = flattenElement(input)
+			expect(result).toEqual({
+				'#/test': {
+					key: 'test',
+					scope: '#/test',
+					type: 'array',
+					value: ['red', 'blue', 'green']
+				},
+				'#/test/[0]': { value: 'red', type: 'string', scope: '#/test/[0]', key: '[0]' },
+				'#/test/[1]': { value: 'blue', type: 'string', scope: '#/test/[1]', key: '[1]' },
+				'#/test/[2]': { value: 'green', type: 'string', scope: '#/test/[2]', key: '[2]' }
+			})
+		})
+
+		it('should flatten an object element', () => {
+			const input = {
+				key: 'test',
+				value: {
+					red: '#FF0000',
+					blue: '#0000FF',
+					green: '#00FF00'
+				},
+				type: 'object',
+				scope: '#/test'
+			}
+			const result = flattenElement(input)
+			expect(result).toEqual({
+				'#/test': {
+					key: 'test',
+					scope: '#/test',
+					type: 'object',
+					value: {
+						blue: '#0000FF',
+						green: '#00FF00',
+						red: '#FF0000'
+					}
+				},
+				'#/test/red': {
+					key: 'red',
+					scope: '#/test/red',
+					type: 'string',
+					value: '#FF0000'
+				},
+				'#/test/blue': {
+					key: 'blue',
+					scope: '#/test/blue',
+					type: 'string',
+					value: '#0000FF'
+				},
+				'#/test/green': {
+					key: 'green',
+					scope: '#/test/green',
+					type: 'string',
+					value: '#00FF00'
+				}
+			})
+		})
+	})
+
+	describe('deriveNestedSchema', () => {
+		it('should handle simple object', () => {
+			const result = deriveNestedSchema({ count: 10, enabled: true, label: 'test' })
+			expect(result).toEqual([
+				{
+					layout: {
+						elements: [
+							{
+								label: 'count',
+								scope: '#/count'
+							},
+							{
+								label: 'enabled',
+								scope: '#/enabled'
+							},
+							{
+								label: 'label',
+								scope: '#/label'
+							}
+						],
+						type: 'vertical'
+					},
+					properties: {
+						count: {
+							default: 10,
+							type: 'integer'
+						},
+						enabled: {
+							default: true,
+							type: 'boolean'
+						},
+						label: {
+							default: 'test',
+							type: 'string'
+						}
+					},
+					type: 'object'
+				}
+			])
+		})
+
+		it('should handle empty array', () => {
+			const result = deriveNestedSchema({ items: [] })
+			expect(result).toEqual([
+				{
+					default: [],
+					items: {
+						type: 'string'
+					},
+					layout: {
+						type: 'vertical',
+						elements: [
+							{
+								scope: '#'
+							}
+						]
+					},
+					key: 'items',
+					scope: '#/items',
+					type: 'array'
+				}
+			])
+		})
+
+		it('should handle string array', () => {
+			const result = deriveNestedSchema({ items: ['red', 'blue', 'green'] })
+			expect(result).toEqual([
+				{
+					default: [],
+					items: {
+						type: 'string'
+					},
+					layout: {
+						type: 'vertical',
+						elements: [
+							{
+								scope: '#'
+							}
+						]
+					},
+					key: 'items',
+					scope: '#/items',
+					type: 'array'
+				}
+			])
+		})
+
+		it('should handle object array', () => {
+			const result = deriveNestedSchema({
+				modules: [
+					{
+						name: 'module1',
+						enabled: true
+					},
+					{
+						name: 'module2',
+						enabled: false
+					}
+				]
+			})
+			expect(result).toEqual([
+				{
+					default: [],
+					items: {
+						type: 'object',
+
+						properties: {
+							enabled: {
+								type: 'boolean'
+							},
+							name: {
+								type: 'string'
+							}
+						}
+					},
+					layout: {
+						type: 'vertical',
+						elements: [
+							{
+								label: 'name',
+								scope: '#/name'
+							},
+							{
+								label: 'enabled',
+								scope: '#/enabled'
+							}
+						]
+					},
+					key: 'modules',
+					scope: '#/modules',
+					type: 'array'
+				}
+			])
+		})
+
+		it('should generate a nested schema', () => {
+			const result = deriveNestedSchema({
+				theme: {
+					primary: {
+						main: '#2196F3',
+						count: 10,
+						enabled: true
+					}
+				}
+			})
+
+			expect(result).toEqual([
+				{
+					children: [
+						{
+							key: 'primary',
+							layout: {
+								elements: [
+									{
+										label: 'main',
+										scope: '#/main'
+									},
+									{
+										label: 'count',
+										scope: '#/count'
+									},
+									{
+										label: 'enabled',
+										scope: '#/enabled'
+									}
+								],
+								type: 'vertical'
+							},
+							scope: '#/theme/primary',
+							properties: {
+								count: {
+									default: 10,
+									type: 'integer'
+								},
+								enabled: {
+									default: true,
+									type: 'boolean'
+								},
+								main: {
+									default: '#2196F3',
+									type: 'string'
+								}
+							},
+							type: 'object'
+						}
+					],
+					key: 'theme',
+					scope: '#/theme',
+					type: 'object'
+				}
+			])
+		})
+	})
+	describe('generateIndex', () => {
+		it('should generate an index', () => {
+			const input = [
+				{ scope: '#/root' },
+				{ scope: '#/root/child1' },
+				{ scope: '#/root/child2' },
+				{ scope: '#/anotherRoot' },
+				{ scope: '#/anotherRoot/child1' }
+			]
+			const result = generateIndex(input)
+			expect(result).toEqual([
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: true,
+
+					_levels: [0],
+					_path: '#/anotherRoot',
+					scope: '#/anotherRoot'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [0, 0],
+					_path: '#/anotherRoot/child1',
+					scope: '#/anotherRoot/child1'
+				},
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: true,
+
+					_levels: [1],
+					_path: '#/root',
+					scope: '#/root'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [1, 0],
+					_path: '#/root/child1',
+					scope: '#/root/child1'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [1, 1],
+					_path: '#/root/child2',
+					scope: '#/root/child2'
+				}
+			])
+		})
+	})
+
+	describe('generateTreeTable', () => {
+		it('should generate an empty tree table', () => {
+			let result = generateTreeTable(null)
+			expect(result).toEqual([])
+			result = generateTreeTable('')
+			expect(result).toEqual([])
+		})
+		it('should generate a tree table for object array', () => {
+			const result = generateTreeTable([
+				{ scope: '#/color', value: 'red' },
+				{ scope: '#/theme', value: 'ocean' }
+			])
+			expect(result).toEqual([
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: true,
+
+					_levels: [0],
+					_path: '#/0',
+					key: '0',
+					scope: '#/0',
+					type: 'object',
+					value: { scope: '#/color', value: 'red' }
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [0, 0],
+					_path: '#/0/scope',
+					key: 'scope',
+					scope: '#/0/scope',
+					type: 'string',
+					value: '#/color'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [0, 1],
+					_path: '#/0/value',
+					key: 'value',
+					scope: '#/0/value',
+					type: 'string',
+					value: 'red'
+				},
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: true,
+					_levels: [1],
+					_path: '#/1',
+					key: '1',
+					scope: '#/1',
+					type: 'object',
+					value: {
+						scope: '#/theme',
+						value: 'ocean'
+					}
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [1, 0],
+					_path: '#/1/scope',
+					key: 'scope',
+					scope: '#/1/scope',
+					type: 'string',
+					value: '#/theme'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [1, 1],
+					_path: '#/1/value',
+					key: 'value',
+					scope: '#/1/value',
+					type: 'string',
+					value: 'ocean'
+				}
+			])
+		})
+		it('should generate a tree table for object', () => {
+			const result = generateTreeTable({
+				red: '#FF0000',
+				blue: '#0000FF',
+				green: '#00FF00'
+			})
+			expect(result).toEqual([
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [0],
+					_path: '#/blue',
+					scope: '#/blue',
+					key: 'blue',
+					type: 'string',
+					value: '#0000FF'
+				},
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [1],
+					_path: '#/green',
+					scope: '#/green',
+					key: 'green',
+					type: 'string',
+					value: '#00FF00'
+				},
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: false,
+
+					_levels: [2],
+					_path: '#/red',
+					scope: '#/red',
+					key: 'red',
+					type: 'string',
+					value: '#FF0000'
+				}
+			])
+		})
+
+		it('should use ellipsis to truncate data', () => {
+			const data = {
+				red: [1, 2]
+			}
+			const result = generateTreeTable(data, 'scope', true)
+			expect(result).toEqual([
+				{
+					_depth: 0,
+					_isExpanded: true,
+					_isParent: true,
+					_levels: [0],
+					_path: '#/red',
+					key: 'red',
+					scope: '#/red',
+					type: 'array',
+					value: '...'
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [0, 0],
+					_path: '#/red/[0]',
+					key: '[0]',
+					scope: '#/red/[0]',
+					type: 'integer',
+					value: 1
+				},
+				{
+					_depth: 1,
+					_isExpanded: true,
+					_isParent: false,
+					_levels: [0, 1],
+					_path: '#/red/[1]',
+					key: '[1]',
+					scope: '#/red/[1]',
+					type: 'integer',
+					value: 2
+				}
+			])
+		})
+	})
+})

package/src/lib/deprecated/validator.js

@@ -0,0 +1,137 @@
+import { writable } from 'svelte/store'
+import { omit } from 'ramda'
+
+/**
+ * Get a validator function that takes a regex expression and returns a validation function
+ *
+ * @param {string|RegExp} pattern
+ * @returns {import('./types').ValidationFunction}
+ */
+export function getPatternValidator(pattern) {
+	if (typeof pattern === 'string') {
+		return (input) => input && input.match(pattern) !== null
+	} else if (pattern instanceof RegExp) {
+		return (input) => input && pattern.test(input)
+	} else {
+		throw new Error('Invalid pattern')
+	}
+}
+
+const TYPE_VALIDATORS = {
+	string: (input) => typeof input === 'string',
+	number: (input) => input !== null && !isNaN(input),
+	email: getPatternValidator(/^[^@]+@[^@]+\.[^@]+$/),
+	url: getPatternValidator(/^(https?:\/\/\S+)$/),
+	color: getPatternValidator(/^#[0-9a-fA-F]{6}$/),
+	date: (input) => input !== null && !isNaN(new Date(input).getTime()),
+	array: (input) => Array.isArray(input),
+	object: (input) => input !== null && typeof input === 'object' && !Array.isArray(input)
+}
+
+/**
+ * Check if the input is a valid number
+ *
+ * @param {*} input
+ * @returns {boolean}
+ */
+function isValidNumber(input) {
+	return input !== null && input !== undefined && !isNaN(input)
+}
+
+/**
+ * Get a validator function that takes a min and max value and returns a validation function
+ *
+ * @param {number} min
+ * @param {number} max
+ * @returns {import('./types').ValidationFunction}
+ */
+export function getRangeValidator(min, max) {
+	if (!isValidNumber(min)) return (input) => isValidNumber(input) && input <= max
+	if (!isValidNumber(max)) return (input) => isValidNumber(input) && input >= min
+	return (input) => isValidNumber(input) && input >= min && input <= max
+}
+
+/**
+ * Get a validator function that takes a type and returns a validation function
+ *
+ * @param {string} type
+ * @returns {import('./types').ValidationFunction}
+ * @throws {Error} - If the type is invalid
+ */
+export function getTypeValidator(type) {
+	if (type in TYPE_VALIDATORS) return TYPE_VALIDATORS[type]
+
+	return (input) => typeof input === type
+}
+
+/**
+ * Get a validator function for the given rule.
+ *
+ * @param {import('./types').ValidationRule} rule - The rule to get the validator for.
+ * @returns {import('./types').ValidationFunction} - The validator function.
+ * @throws {Error} - If the rule is invalid.
+ */
+function getValidator(rule) {
+	const { validator, pattern = null, min = null, max = null, type = null } = rule
+	const strategies = [
+		{ satisfies: typeof validator === 'function', validator },
+		{ satisfies: pattern !== null, validator: getPatternValidator(pattern ?? '*') },
+		{ satisfies: min !== null || max !== null, validator: getRangeValidator(min, max) },
+		{ satisfies: type !== null, validator: getTypeValidator(type) }
+	]
+
+	const result = strategies.find((x) => x.satisfies)
+	if (result) return result.validator
+
+	throw new Error('Invalid rule')
+}
+
+/**
+ * Evaluate the validation rules for the given value.
+ *
+ * @param {*} value - The value to evaluate.
+ * @param {Array<import('./types').ValidationRule>} rules - An array of validation rules.
+ * @returns {import('./types').ValidationResult} - The result of the evaluation.
+ */
+function evaluateRules(value, rules) {
+	let status = 'pass'
+	const validations = []
+
+	rules.forEach((rule) => {
+		const valid = rule.validator(value)
+		const result = {
+			text: rule.text,
+			valid,
+			status: valid ? 'pass' : rule.optional ? 'warn' : 'fail'
+		}
+
+		if (status !== 'fail' && !valid) status = result.status
+		validations.push(result)
+	})
+
+	return { value, status, validations, isValid: status === 'pass' }
+}
+
+/**
+ * Create a custom Svelte store with validation rules.
+ * @param {*} value - The initial value for the store.
+ * @param {Array<import('./types').ValidationRule>} rules - An array of validation rules.
+ * @returns {import('svelte').Writable<import('./types').ValidationResult>} - The custom Svelte store.
+ */
+export function verifiable(input, rules) {
+	const result = writable({ value: input })
+
+	rules = (rules ?? []).map((rule) => ({
+		...rule,
+		validator: getValidator(rule)
+	}))
+
+	const evaluate = (value) => result.set(evaluateRules(value, rules))
+
+	evaluate(input)
+
+	return {
+		...omit(['set'], result),
+		update: evaluate
+	}
+}