@soft-stech/bootsman-ui-shadcn 2.0.0 → 2.0.2

package/src/components/auto-form/utils.ts

@@ -1,171 +0,0 @@
-import type { z } from 'zod'
-
-// TODO: This should support recursive ZodEffects but TypeScript doesn't allow circular type definitions.
-export type ZodObjectOrWrapped =
-  | z.ZodObject<any, any>
-  | z.ZodEffects<z.ZodObject<any, any>>
-
-/**
- * Beautify a camelCase string.
- * e.g. "myString" -> "My String"
- */
-export function beautifyObjectName(string: string) {
-  // Remove bracketed indices
-  // if numbers only return the string
-  let output = string.replace(/\[\d+\]/g, '').replace(/([A-Z])/g, ' $1')
-  output = output.charAt(0).toUpperCase() + output.slice(1)
-  return output
-}
-
-/**
- * Parse string and extract the index
- * @param string
- * @returns index or undefined
- */
-export function getIndexIfArray(string: string) {
-  const indexRegex = /\[(\d+)\]/
-  // Match the index
-  const match = string.match(indexRegex)
-  // Extract the index (number)
-  const index = match ? Number.parseInt(match[1]) : undefined
-  return index
-}
-
-/**
- * Get the lowest level Zod type.
- * This will unpack optionals, refinements, etc.
- */
-export function getBaseSchema<
-  ChildType extends z.ZodAny | z.AnyZodObject = z.ZodAny,
->(schema: ChildType | z.ZodEffects<ChildType>): ChildType | null {
-  if (!schema)
-    return null
-  if ('innerType' in schema._def)
-    return getBaseSchema(schema._def.innerType as ChildType)
-
-  if ('schema' in schema._def)
-    return getBaseSchema(schema._def.schema as ChildType)
-
-  return schema as ChildType
-}
-
-/**
- * Get the type name of the lowest level Zod type.
- * This will unpack optionals, refinements, etc.
- */
-export function getBaseType(schema: z.ZodAny) {
-  const baseSchema = getBaseSchema(schema)
-  return baseSchema ? baseSchema._def.typeName : ''
-}
-
-/**
- * Search for a "ZodDefault" in the Zod stack and return its value.
- */
-export function getDefaultValueInZodStack(schema: z.ZodAny): any {
-  const typedSchema = schema as unknown as z.ZodDefault<
-    z.ZodNumber | z.ZodString
-  >
-
-  if (typedSchema._def.typeName === 'ZodDefault')
-    return typedSchema._def.defaultValue()
-
-  if ('innerType' in typedSchema._def) {
-    return getDefaultValueInZodStack(
-      typedSchema._def.innerType as unknown as z.ZodAny,
-    )
-  }
-  if ('schema' in typedSchema._def) {
-    return getDefaultValueInZodStack(
-      (typedSchema._def as any).schema as z.ZodAny,
-    )
-  }
-
-  return undefined
-}
-
-export function getObjectFormSchema(
-  schema: ZodObjectOrWrapped,
-): z.ZodObject<any, any> {
-  if (schema?._def.typeName === 'ZodEffects') {
-    const typedSchema = schema as z.ZodEffects<z.ZodObject<any, any>>
-    return getObjectFormSchema(typedSchema._def.schema)
-  }
-  return schema as z.ZodObject<any, any>
-}
-
-function isIndex(value: unknown): value is number {
-  return Number(value) >= 0
-}
-/**
- * Constructs a path with dot paths for arrays to use brackets to be compatible with vee-validate path syntax
- */
-export function normalizeFormPath(path: string): string {
-  const pathArr = path.split('.')
-  if (!pathArr.length)
-    return ''
-
-  let fullPath = String(pathArr[0])
-  for (let i = 1; i < pathArr.length; i++) {
-    if (isIndex(pathArr[i])) {
-      fullPath += `[${pathArr[i]}]`
-      continue
-    }
-
-    fullPath += `.${pathArr[i]}`
-  }
-
-  return fullPath
-}
-
-type NestedRecord = Record<string, unknown> | { [k: string]: NestedRecord }
-/**
- * Checks if the path opted out of nested fields using `[fieldName]` syntax
- */
-export function isNotNestedPath(path: string) {
-  return /^\[.+\]$/.test(path)
-}
-function isObject(obj: unknown): obj is Record<string, unknown> {
-  return obj !== null && !!obj && typeof obj === 'object' && !Array.isArray(obj)
-}
-function isContainerValue(value: unknown): value is Record<string, unknown> {
-  return isObject(value) || Array.isArray(value)
-}
-function cleanupNonNestedPath(path: string) {
-  if (isNotNestedPath(path))
-    return path.replace(/\[|\]/g, '')
-
-  return path
-}
-
-/**
- * Gets a nested property value from an object
- */
-export function getFromPath<TValue = unknown>(object: NestedRecord | undefined, path: string): TValue | undefined
-export function getFromPath<TValue = unknown, TFallback = TValue>(
-  object: NestedRecord | undefined,
-  path: string,
-  fallback?: TFallback,
-): TValue | TFallback
-export function getFromPath<TValue = unknown, TFallback = TValue>(
-  object: NestedRecord | undefined,
-  path: string,
-  fallback?: TFallback,
-): TValue | TFallback | undefined {
-  if (!object)
-    return fallback
-
-  if (isNotNestedPath(path))
-    return object[cleanupNonNestedPath(path)] as TValue | undefined
-
-  const resolvedValue = (path || '')
-    .split(/\.|\[(\d+)\]/)
-    .filter(Boolean)
-    .reduce((acc, propKey) => {
-      if (isContainerValue(acc) && propKey in acc)
-        return acc[propKey]
-
-      return fallback
-    }, object as unknown)
-
-  return resolvedValue as TValue | undefined
-}

package/src/stories/components/BuiAutoFormStory.vue

@@ -1,113 +0,0 @@
-<script setup lang="ts">
-import { BuiAutoForm } from '@/components/auto-form'
-import { useBuiForm } from '@/components/form'
-import { toTypedSchema } from '@vee-validate/zod'
-import { z } from 'zod'
-
-enum Sports {
-  Football = 'Football/Soccer',
-  Basketball = 'Basketball',
-  Baseball = 'Baseball',
-  Hockey = 'Hockey (Ice)',
-  None = "I don't like sports"
-}
-
-const schema = z.object({
-  addons: z.array(
-    z
-      .object({
-        type: z.nativeEnum(Sports),
-        name: z.string().min(1),
-        email: z.string().email()
-      })
-      .describe('Addon')
-  ),
-  level1: z
-    .object({
-      level2: z.object({
-        level3: z.object({
-          test: z.string().min(1),
-          something: z.boolean(),
-          array: z
-            .object({
-              field1: z.string().min(1),
-              field2: z.string().min(1)
-            })
-            .array()
-        })
-      })
-    })
-    .describe('Level 1'),
-  username: z
-    .string({
-      required_error: 'Username is required.'
-    })
-    .min(2, {
-      message: 'Username must be at least 2 characters.'
-    }),
-
-  password: z
-    .string({
-      required_error: 'Password is required.'
-    })
-    .min(8, {
-      message: 'Password must be at least 8 characters.'
-    }),
-
-  favouriteNumber: z.coerce
-    .number({
-      invalid_type_error: 'Favourite number must be a number.'
-    })
-    .min(1, {
-      message: 'Favourite number must be at least 1.'
-    })
-    .max(10, {
-      message: 'Favourite number must be at most 10.'
-    })
-    .default(1)
-    .optional(),
-
-  acceptTerms: z.boolean().refine((value) => value, {
-    message: 'You must accept the terms and conditions.',
-    path: ['acceptTerms']
-  }),
-
-  sendMeMails: z.boolean().optional(),
-
-  birthday: z.coerce.date().optional(),
-
-  color: z.enum(['red', 'green', 'blue']).optional(),
-
-  // Another enum example
-  marshmallows: z.enum(['not many', 'a few', 'a lot', 'too many']),
-
-  // Native enum example
-  sports: z.nativeEnum(Sports).describe('What is your favourite sport?'),
-
-  bio: z
-    .string()
-    .min(10, {
-      message: 'Bio must be at least 10 characters.'
-    })
-    .max(160, {
-      message: 'Bio must not be longer than 30 characters.'
-    })
-    .optional(),
-
-  customParent: z.string().optional(),
-
-  file: z.string().optional()
-})
-
-const form = useBuiForm({
-  validationSchema: toTypedSchema(schema)
-})
-</script>
-
-<template>
-  <Story title="BuiAutoForm" autoPropsDisabled :layout="{ type: 'grid', width: '100%' }">
-    <Variant title="Default">
-      <BuiAutoForm :schema="schema" :form="form" class="m-4" />
-    </Variant>
-  </Story>
-</template>