@rokkit/forms 1.0.0-next.125 → 1.0.0-next.128

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

@@ -1,512 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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
-	}
-}