@oxcide-ui/schema 0.0.3

package/dist/index.js

@@ -0,0 +1,381 @@
+// src/components/badge.ts
+import { z } from "zod";
+var badgePropsSchema = z.object({
+  /** Severity / semantic color */
+  severity: z.enum(["primary", "secondary", "success", "info", "warning", "danger", "help", "contrast"]).default("primary"),
+  /** Size */
+  size: z.enum(["xs", "sm", "md", "lg", "xl"]).default("md"),
+  /** Value to display */
+  value: z.union([z.string(), z.number()]).optional()
+});
+function getBadgeDefaults(props = {}) {
+  return badgePropsSchema.parse(props);
+}
+
+// src/components/box.ts
+import { z as z2 } from "zod";
+var boxPropsSchema = z2.object({
+  as: z2.string().default("div")
+});
+function getBoxDefaults(props = {}) {
+  return boxPropsSchema.parse(props);
+}
+
+// src/components/button.ts
+import { z as z3 } from "zod";
+var buttonPropsSchema = z3.object({
+  /** Visual variant */
+  variant: z3.enum(["solid", "outline", "ghost", "link"]).default("solid"),
+  /** Size */
+  size: z3.enum(["xs", "sm", "md", "lg", "xl"]).default("md"),
+  /** Severity / semantic color */
+  severity: z3.enum(["primary", "secondary", "success", "info", "warning", "danger", "help", "contrast"]).default("primary"),
+  /** Disabled state */
+  disabled: z3.boolean().default(false),
+  /** Loading state */
+  loading: z3.boolean().default(false),
+  /** Icon name from the library */
+  icon: z3.string().optional(),
+  /** Icon position relative to label */
+  iconPos: z3.enum(["left", "right"]).default("left"),
+  /** Loading icon name */
+  loadingIcon: z3.string().optional().default("spinner"),
+  /** Button label text */
+  label: z3.string().optional(),
+  /** Render as rounded pill */
+  rounded: z3.boolean().default(false),
+  /** Render as text-only (no background/border) */
+  text: z3.boolean().default(false),
+  /** Render as raised with shadow */
+  raised: z3.boolean().default(false)
+});
+function getButtonDefaults(props = {}) {
+  return buttonPropsSchema.parse(props);
+}
+
+// src/components/checkbox.ts
+import { z as z4 } from "zod";
+var checkboxPropsSchema = z4.object({
+  /** V-model value */
+  modelValue: z4.any().optional(),
+  /** Value for array-based checkboxes */
+  value: z4.any().optional(),
+  /** Value when checked */
+  onValue: z4.any().default(true),
+  /** Value when unchecked */
+  offValue: z4.any().default(false),
+  /** Treat modelValue as boolean regardless of value or switch to boolean mode */
+  binary: z4.boolean().default(false),
+  /** Disabled state */
+  disabled: z4.boolean().default(false),
+  /** Invalid / Error state */
+  invalid: z4.boolean().default(false),
+  /** Readonly state */
+  readonly: z4.boolean().default(false),
+  /** Label text (next to checkbox) */
+  label: z4.string().optional(),
+  /** Position of the label */
+  labelPosition: z4.enum(["left", "right"]).default("right"),
+  /** Custom icon when checked */
+  icon: z4.string().optional(),
+  /** Indeterminate state */
+  indeterminate: z4.boolean().default(false),
+  /** Size */
+  size: z4.enum(["sm", "md", "lg"]).default("md"),
+  /** Severity */
+  severity: z4.enum(["primary", "secondary", "success", "info", "warning", "danger", "help", "contrast"]).default("primary"),
+  /** Native name attribute */
+  name: z4.string().optional(),
+  /** Native id attribute */
+  id: z4.string().optional()
+});
+function getCheckboxDefaults(props = {}) {
+  return checkboxPropsSchema.parse(props);
+}
+
+// src/components/dialog.ts
+import { z as z5 } from "zod";
+var dialogPropsSchema = z5.object({
+  /** Modal visibility */
+  visible: z5.boolean().default(false),
+  /** Header text */
+  header: z5.string().optional(),
+  /** Footer text */
+  footer: z5.string().optional(),
+  /** Whether the dialog can be closed */
+  closable: z5.boolean().default(true),
+  /** Custom icon for the close button */
+  closeIcon: z5.string().default("times"),
+  /** Whether clicking the mask closes the dialog */
+  dismissableMask: z5.boolean().default(false),
+  /** Whether to close on Escape key */
+  closeOnEscape: z5.boolean().default(true),
+  /** Teleport target selector or element */
+  appendTo: z5.any().default("#teleports"),
+  /** Style class for the mask */
+  maskClass: z5.string().optional(),
+  /** Modal state */
+  modal: z5.boolean().default(true),
+  /** Whether to show the header */
+  showHeader: z5.boolean().default(true),
+  /** Custom style object */
+  style: z5.any().optional(),
+  /** Custom class name */
+  class: z5.any().optional(),
+  /** Dialog position */
+  position: z5.enum(["center", "top", "bottom", "left", "right", "top-left", "top-right", "bottom-left", "bottom-right"]).default("center"),
+  /** Native id attribute */
+  id: z5.string().optional()
+});
+function getDialogDefaults(props = {}) {
+  return dialogPropsSchema.parse(props);
+}
+
+// src/components/icon.ts
+import { z as z6 } from "zod";
+var iconPropsSchema = z6.object({
+  /** Icon name from the library */
+  name: z6.string().default(""),
+  /** Icon size (CSS value) */
+  size: z6.union([z6.string(), z6.number()]).optional().default("1em"),
+  /** Icon color (CSS value) */
+  color: z6.string().optional(),
+  /** Whether the icon should spin */
+  spin: z6.boolean().optional().default(false)
+});
+function getIconDefaults(props = {}) {
+  return iconPropsSchema.parse(props);
+}
+
+// src/components/input.ts
+import { z as z7 } from "zod";
+var inputPropsSchema = z7.object({
+  /** Input value */
+  modelValue: z7.string().optional(),
+  /** Size */
+  size: z7.enum(["sm", "md", "lg"]).default("md"),
+  /** Disabled state */
+  disabled: z7.boolean().default(false),
+  /** Readonly state */
+  readonly: z7.boolean().default(false),
+  /** Invalid / Error state */
+  invalid: z7.boolean().default(false),
+  /** Width 100% */
+  fluid: z7.boolean().default(false),
+  /** Icon to display on the left */
+  iconLeft: z7.string().optional(),
+  /** Icon to display on the right */
+  iconRight: z7.string().optional(),
+  /** Whether the input is clearable */
+  clearable: z7.boolean().default(false),
+  /** Placeholder text */
+  placeholder: z7.string().optional(),
+  /** Native type attribute */
+  type: z7.string().default("text"),
+  /** Native name attribute */
+  name: z7.string().optional(),
+  /** Native id attribute */
+  id: z7.string().optional()
+});
+function getInputDefaults(props = {}) {
+  return inputPropsSchema.parse(props);
+}
+
+// src/components/radiobutton.ts
+import { z as z8 } from "zod";
+var radioButtonPropsSchema = z8.object({
+  /** V-model selected value */
+  modelValue: z8.any().optional(),
+  /** Value representing this specific radio button */
+  value: z8.any().optional(),
+  /** Disabled state */
+  disabled: z8.boolean().default(false),
+  /** Invalid / Error state */
+  invalid: z8.boolean().default(false),
+  /** Readonly state */
+  readonly: z8.boolean().default(false),
+  /** Size */
+  size: z8.enum(["sm", "md", "lg"]).default("md"),
+  /** Severity */
+  severity: z8.enum(["primary", "secondary", "success", "info", "warning", "danger", "help", "contrast"]).default("primary"),
+  /** Variant */
+  variant: z8.enum(["filled", "outlined"]).default("filled"),
+  /** Label for accessibility and grouping */
+  label: z8.string().optional(),
+  /** Position of the label */
+  labelPosition: z8.enum(["left", "right"]).default("right"),
+  /** Group name for radios */
+  name: z8.string().optional(),
+  /** Native id attribute */
+  id: z8.string().optional()
+});
+function getRadioButtonDefaults(props = {}) {
+  return radioButtonPropsSchema.parse(props);
+}
+
+// src/components/stack.ts
+import { z as z9 } from "zod";
+var stackPropsSchema = z9.object({
+  as: z9.string().default("div"),
+  direction: z9.enum(["row", "column", "row-reverse", "column-reverse"]).default("column"),
+  gap: z9.enum(["none", "xs", "sm", "md", "lg", "xl", "2xl"]).default("md"),
+  align: z9.enum(["start", "center", "end", "stretch", "baseline"]).default("stretch"),
+  justify: z9.enum(["start", "center", "end", "between", "around", "evenly"]).default("start"),
+  wrap: z9.enum(["nowrap", "wrap", "wrap-reverse"]).default("nowrap"),
+  fluid: z9.boolean().default(false)
+});
+function getStackDefaults(props = {}) {
+  return stackPropsSchema.parse(props);
+}
+
+// src/components/switch.ts
+import { z as z10 } from "zod";
+var switchPropsSchema = z10.object({
+  /** V-model value */
+  modelValue: z10.any().optional(),
+  /** Value for 'on' state */
+  onValue: z10.any().default(true),
+  /** Value for 'off' state */
+  offValue: z10.any().default(false),
+  /** Disabled state */
+  disabled: z10.boolean().default(false),
+  /** Invalid / Error state */
+  invalid: z10.boolean().default(false),
+  /** Readonly state */
+  readonly: z10.boolean().default(false),
+  /** Label (next to the switch) */
+  label: z10.string().optional(),
+  /** Position of the label */
+  labelPosition: z10.enum(["left", "right"]).default("right"),
+  /** Icon to display when switch is on */
+  trueIcon: z10.string().optional(),
+  /** Icon to display when switch is off */
+  falseIcon: z10.string().optional(),
+  /** Size of the switch */
+  size: z10.enum(["sm", "md", "lg"]).default("md"),
+  /** Native id attribute */
+  id: z10.string().optional()
+});
+function getSwitchDefaults(props = {}) {
+  return switchPropsSchema.parse(props);
+}
+
+// src/components/tag.ts
+import { z as z11 } from "zod";
+var tagPropsSchema = z11.object({
+  /** Tag label / content */
+  value: z11.string().optional(),
+  /** Severity / semantic color */
+  severity: z11.enum(["primary", "secondary", "success", "info", "warning", "danger", "help", "contrast"]).default("primary"),
+  /** Rounded / pill shape */
+  rounded: z11.boolean().default(false),
+  /** Icon name from the library */
+  icon: z11.string().optional(),
+  /** Show close icon */
+  closable: z11.boolean().default(false)
+});
+function getTagDefaults(props = {}) {
+  return tagPropsSchema.parse(props);
+}
+
+// src/components/toast.ts
+import { z as z12 } from "zod";
+var toastSeveritySchema = z12.enum([
+  "success",
+  "info",
+  "warning",
+  "danger",
+  "secondary",
+  "help",
+  "contrast",
+  "primary"
+]);
+var toastMessageSchema = z12.object({
+  id: z12.string().optional(),
+  severity: toastSeveritySchema.default("info"),
+  summary: z12.string().optional(),
+  detail: z12.string().optional(),
+  life: z12.number().optional().default(3e3),
+  sticky: z12.boolean().optional().default(false),
+  closable: z12.boolean().optional().default(true),
+  icon: z12.string().optional(),
+  group: z12.string().optional()
+});
+var toastPropsSchema = z12.object({
+  position: z12.enum(["top-left", "top-center", "top-right", "bottom-left", "bottom-center", "bottom-right", "center"]).default("top-right"),
+  group: z12.string().optional(),
+  baseZIndex: z12.number().optional().default(0),
+  autoZIndex: z12.boolean().optional().default(true),
+  /** Teleport target selector or element */
+  appendTo: z12.any().default("#teleports")
+});
+function getToastDefaults(props = {}) {
+  return toastPropsSchema.parse(props);
+}
+
+// src/registry.ts
+import { z as z13 } from "zod";
+var registryItemFileSchema = z13.object({
+  /** Relative file path */
+  path: z13.string(),
+  /** File content as string */
+  content: z13.string(),
+  /** File type hint */
+  type: z13.enum(["component", "style", "schema", "composable", "util"]).optional()
+});
+var registryItemSchema = z13.object({
+  /** Component name (kebab-case) */
+  name: z13.string(),
+  /** Component type */
+  type: z13.enum(["component", "primitive", "composable", "util"]).default("component"),
+  /** Human-readable description */
+  description: z13.string().optional(),
+  /** Source files */
+  files: z13.array(registryItemFileSchema),
+  /** npm dependencies required by this component */
+  dependencies: z13.array(z13.string()).default([]),
+  /** Other registry components this one depends on */
+  registryDependencies: z13.array(z13.string()).default([]),
+  /** CSS file paths (if separately bundled) */
+  cssFiles: z13.array(z13.string()).default([])
+});
+var registryIndexSchema = z13.array(
+  z13.object({
+    name: z13.string(),
+    type: z13.string(),
+    description: z13.string().optional(),
+    dependencies: z13.array(z13.string()).default([]),
+    registryDependencies: z13.array(z13.string()).default([])
+  })
+);
+export {
+  badgePropsSchema,
+  boxPropsSchema,
+  buttonPropsSchema,
+  checkboxPropsSchema,
+  dialogPropsSchema,
+  getBadgeDefaults,
+  getBoxDefaults,
+  getButtonDefaults,
+  getCheckboxDefaults,
+  getDialogDefaults,
+  getIconDefaults,
+  getInputDefaults,
+  getRadioButtonDefaults,
+  getStackDefaults,
+  getSwitchDefaults,
+  getTagDefaults,
+  getToastDefaults,
+  iconPropsSchema,
+  inputPropsSchema,
+  radioButtonPropsSchema,
+  registryIndexSchema,
+  registryItemFileSchema,
+  registryItemSchema,
+  stackPropsSchema,
+  switchPropsSchema,
+  tagPropsSchema,
+  toastMessageSchema,
+  toastPropsSchema,
+  toastSeveritySchema
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@oxcide-ui/schema",
+  "version": "0.0.3",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "import": "./dist/components/index.js",
+      "require": "./dist/components/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "zod": "3.25.76",
+    "@oxcide-ui/icons": "0.0.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "picocolors": "1.1.1",
+    "ts-morph": "^27.0.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm type-sync && tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "pnpm type-sync && tsup src/index.ts --format esm,cjs --dts --watch",
+    "type-check": "tsc --noEmit",
+    "type-sync": "tsx scripts/sync-types.ts && pnpm lint:fix",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write ."
+  }
+}

package/scripts/sync-types.ts

@@ -0,0 +1,105 @@
+import { Project } from 'ts-morph'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import pc from 'picocolors'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const rootPath = path.resolve(__dirname, '../src/components')
+
+async function syncTypes() {
+  console.log(pc.cyan('\n🚀 Starting type synchronization (Direct Mode)...\n'))
+
+  const project = new Project({
+    tsConfigFilePath: path.resolve(__dirname, '../tsconfig.json'),
+  })
+
+  const files = project.getSourceFiles(path.join(rootPath, '*.ts'))
+  let updatedCount = 0
+
+  for (const sourceFile of files) {
+    const filePath = sourceFile.getFilePath()
+    const fileName = path.basename(filePath)
+    
+    if (fileName === 'index.ts' || fileName.endsWith('.d.ts')) continue
+
+    // Find the schema name (e.g., buttonPropsSchema)
+    const schemaVar = sourceFile.getVariableDeclaration((v) => v.getName().endsWith('PropsSchema'))
+    if (!schemaVar) {
+      if (!fileName.includes('types')) {
+        console.warn(pc.yellow(`⚠️  Could not find a variable ending with 'PropsSchema' in ${fileName}. Skipping.`))
+      }
+      continue
+    }
+
+    const schemaName = schemaVar.getName()
+    const baseName = schemaName.replace('PropsSchema', '')
+    const capitalizedBaseName = baseName.charAt(0).toUpperCase() + baseName.slice(1)
+
+    console.log(`${pc.blue('⏳')} Syncing ${pc.bold(pc.white(fileName))}...`)
+
+    let content = sourceFile.getFullText()
+
+    // 1. Detect existing sync block
+    const syncBlockRegex = new RegExp(
+      `\\/\\* @oxcide-sync:source[\\s\\S]*?@oxcide-sync:end \\*\\/[\\s\\S]*?(?=export function|$)`,
+      'g',
+    )
+
+    // 2. Detect original Zod inference lines
+    const originalRegex = new RegExp(
+      `export type ${capitalizedBaseName}Props = z\\.input<typeof ${schemaName}>;?\\s+` +
+        `export type ${capitalizedBaseName}ResolvedProps = z\\.infer<typeof ${schemaName}>;?`,
+      'g',
+    )
+
+    // Create temporary types to resolve the expansion
+    const tempInputType = sourceFile.addTypeAlias({
+      name: `__Temp${capitalizedBaseName}Input`,
+      type: `z.input<typeof ${schemaName}>`,
+    })
+    const tempResolvedType = sourceFile.addTypeAlias({
+      name: `__Temp${capitalizedBaseName}Resolved`,
+      type: `z.infer<typeof ${schemaName}>`,
+    })
+
+    const inputTypeText = tempInputType.getType().getApparentType().getText(tempInputType)
+    const resolvedTypeText = tempResolvedType.getType().getApparentType().getText(tempResolvedType)
+
+    tempInputType.remove()
+    tempResolvedType.remove()
+
+    const newSyncBlock = [
+      `/* @oxcide-sync:source`,
+      `export type ${capitalizedBaseName}Props = z.input<typeof ${schemaName}>`,
+      `export type ${capitalizedBaseName}ResolvedProps = z.infer<typeof ${schemaName}>`,
+      `@oxcide-sync:end */`,
+      `export interface ${capitalizedBaseName}Props ${inputTypeText}`,
+      `export type ${capitalizedBaseName}ResolvedProps = ${resolvedTypeText}`,
+      '\n',
+    ].join('\n')
+
+    let newContent = ''
+    if (syncBlockRegex.test(content)) {
+      newContent = content.replace(syncBlockRegex, newSyncBlock)
+    } else if (originalRegex.test(content)) {
+      newContent = content.replace(originalRegex, newSyncBlock)
+    } else {
+      // If none found, find the schema and append after it
+      console.warn(pc.yellow(`❓ Could not find target declarations in ${fileName}. Appending.`))
+      newContent = content + '\n' + newSyncBlock
+    }
+
+    sourceFile.replaceWithText(newContent)
+    sourceFile.formatText({ indentSize: 2 })
+    await sourceFile.save()
+    console.log(pc.green(`✅ Successfully synced ${pc.bold(fileName)}`))
+    updatedCount++
+  }
+
+  console.log(pc.cyan(`\n✨ Type synchronization complete! Updated ${pc.bold(updatedCount)} files.\n`))
+}
+
+syncTypes().catch((error) => {
+  console.error(pc.red(`\n❌ Type sync failed: ${error.message}\n`))
+  process.exit(1)
+})

package/src/components/badge.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod'
+
+export const badgePropsSchema = z.object({
+  /** Severity / semantic color */
+  severity: z
+    .enum(['primary', 'secondary', 'success', 'info', 'warning', 'danger', 'help', 'contrast'])
+    .default('primary'),
+  /** Size */
+  size: z.enum(['xs', 'sm', 'md', 'lg', 'xl']).default('md'),
+  /** Value to display */
+  value: z.union([z.string(), z.number()]).optional()
+})
+
+/* @oxcide-sync:source
+export type BadgeProps = z.input<typeof badgePropsSchema>
+export type BadgeResolvedProps = z.infer<typeof badgePropsSchema>
+@oxcide-sync:end */
+export interface BadgeProps {
+  severity?: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'help' | 'contrast' | undefined
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | undefined
+  value?: string | number | undefined
+}
+export type BadgeResolvedProps = {
+  severity: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'help' | 'contrast'
+  size: 'xs' | 'sm' | 'md' | 'lg' | 'xl'
+  value?: string | number | undefined
+}
+
+export function getBadgeDefaults(props: BadgeProps = {}): BadgeResolvedProps {
+  return badgePropsSchema.parse(props)
+}

package/src/components/box.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+
+export const boxPropsSchema = z.object({
+  as: z.string().default('div')
+})
+
+export function getBoxDefaults(props: BoxProps = {}): BoxResolvedProps {
+  return boxPropsSchema.parse(props)
+}
+
+/* @oxcide-sync:source
+export type BoxProps = z.input<typeof boxPropsSchema>
+export type BoxResolvedProps = z.infer<typeof boxPropsSchema>
+@oxcide-sync:end */
+export interface BoxProps {
+  as?: string | undefined
+}
+export type BoxResolvedProps = { as: string }