@read-frog/definitions 0.1.1 → 0.1.3

package/src/constants/url.ts

@@ -0,0 +1,22 @@
+export const CHROME_EXTENSION_ORIGIN = "chrome-extension://modkelfkcfjpgbfmnbnllalkiogfofhb"
+export const EDGE_EXTENSION_ORIGIN = "extension://cbcbomlgikfbdnoaohcjfledcoklcjbo"
+
+export const READFROG_DOMAIN = "readfrog.app"
+export const LOCALHOST_DOMAIN = "localhost"
+
+// Browser-accessible TanStack Start dev server.
+export const WEBSITE_DEV_PORT = 8888
+export const WEBSITE_DEV_URL = `http://localhost:${WEBSITE_DEV_PORT}`
+
+// Legacy Next.js Caddy proxy kept for compatibility while the old app is still present.
+export const CADDY_DEV_PORT = 4433
+export const WEBSITE_CADDY_DEV_URL = `https://localhost:${CADDY_DEV_PORT}`
+
+export const WEBSITE_PROD_URL = "https://www.readfrog.app"
+export const TRUSTED_ORIGINS = [CHROME_EXTENSION_ORIGIN, EDGE_EXTENSION_ORIGIN, WEBSITE_PROD_URL]
+export const API_DEV_PORT = 7777
+export const API_DEV_URL = `http://localhost:${API_DEV_PORT}`
+export const API_PROD_URL = "https://api.readfrog.app"
+
+// Domain constants for cookie monitoring and other domain-based operations
+export const AUTH_DOMAINS = [READFROG_DOMAIN, LOCALHOST_DOMAIN] as const

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./constants/app"
+export * from "./constants/auth"
+export * from "./constants/beta-access"
+export * from "./constants/column"
+export * from "./constants/dictionary"
+export * from "./constants/url"
+export * from "./schemas/cell-value"
+export * from "./schemas/version"
+export * from "./types/column"
+export * from "./types/languages"

package/src/schemas/cell-value.ts

@@ -0,0 +1,54 @@
+import type { ColumnConfig } from "@/types/column"
+
+import { z } from "zod"
+
+/**
+ * Create a Zod schema for a cell value based on column config.
+ * All cell schemas are nullable (empty cells are valid).
+ */
+export function createCellSchema(config: ColumnConfig): z.ZodType {
+  switch (config.type) {
+    case "string":
+      return z.string().nullable()
+    case "number":
+      return z.number({ message: "Must be a valid number" }).nullable()
+    case "boolean":
+      return z.boolean().nullable()
+    case "date":
+      return z.iso.date().nullable()
+    case "select":
+      if (config.options.length === 0) {
+        return z.string().nullable()
+      }
+      return z
+        .enum(config.options.map(o => o.id) as [string, ...string[]])
+        .nullable()
+  }
+}
+
+/**
+ * Create a Zod schema for an entire row based on column definitions.
+ * Each column becomes a field in the object schema.
+ */
+export function createRowSchema(
+  columns: Array<{ id: string, name: string, config: ColumnConfig }>,
+): z.ZodObject<Record<string, z.ZodType>> {
+  const shape: Record<string, z.ZodType> = {}
+
+  for (const column of columns) {
+    // Use column name as description for AI schema generation
+    shape[column.id] = createCellSchema(column.config).describe(column.name)
+  }
+
+  return z.object(shape)
+}
+
+/**
+ * Convert row schema to JSON Schema for AI structured outputs.
+ * Use this when generating prompts for LLMs that support structured outputs.
+ */
+export function rowSchemaToJsonSchema(
+  columns: Array<{ id: string, name: string, config: ColumnConfig }>,
+) {
+  return z.toJSONSchema(createRowSchema(columns))
+}

package/src/schemas/version.ts

@@ -0,0 +1,101 @@
+import { z } from "zod"
+
+/**
+ * Semantic version regex pattern
+ * Matches versions like: 1.0.0, 10.20.30
+ * Does NOT match: v1.0.0, 1.0.0-alpha, 1.0, 1.-1.0
+ */
+export const SEMANTIC_VERSION_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+
+/**
+ * Zod schema for semantic version validation
+ * Validates semantic version strings according to SemVer conventions
+ * Requires exactly 3 parts: major.minor.patch
+ *
+ * @example
+ * semanticVersionSchema.parse('1.0.0') // ✓ valid
+ * semanticVersionSchema.parse('10.20.30') // ✓ valid
+ * semanticVersionSchema.parse('1.11') // ✗ throws error (must have 3 parts)
+ * semanticVersionSchema.parse('v1.0.0') // ✗ throws error
+ * semanticVersionSchema.parse('1.0.0-alpha') // ✗ throws error
+ */
+export const semanticVersionSchema = z.string().regex(
+  SEMANTIC_VERSION_REGEX,
+  "Must be a valid semantic version with exactly 3 parts (e.g., 1.0.0, 10.20.30)",
+).refine(
+  (version) => {
+    // Additional validation: ensure all parts are non-negative numbers
+    const parts = version.split(".")
+    return parts.length === 3 && parts.every(part => !Number.isNaN(Number(part)) && Number(part) >= 0)
+  },
+  { message: "Version must have exactly 3 parts and all parts must be non-negative numbers" },
+)
+
+/**
+ * Type for semantic version string
+ */
+export type SemanticVersion = z.infer<typeof semanticVersionSchema>
+
+/**
+ * Version type classification
+ */
+export type VersionType = "major" | "minor" | "patch"
+
+/**
+ * Parse a semantic version string into its components
+ * Validates the input using semanticVersionSchema before parsing
+ *
+ * @param version - The version string to parse (must be in format major.minor.patch)
+ * @returns An object containing the major, minor, and patch numbers
+ * @throws {z.ZodError} If the version string is invalid
+ *
+ * @example
+ * parseSemanticVersion('1.2.3') // { major: 1, minor: 2, patch: 3 }
+ * parseSemanticVersion('10.20.30') // { major: 10, minor: 20, patch: 30 }
+ * parseSemanticVersion('1.0') // throws error - must have 3 parts
+ * parseSemanticVersion('v1.0.0') // throws error - invalid format
+ */
+export function parseSemanticVersion(version: string): {
+  major: number
+  minor: number
+  patch: number
+} {
+  // Validate the version string first
+  const validatedVersion = semanticVersionSchema.parse(version)
+
+  const parts = validatedVersion.split(".")
+  return {
+    major: Number.parseInt(parts[0]!, 10),
+    minor: Number.parseInt(parts[1]!, 10),
+    patch: Number.parseInt(parts[2]!, 10),
+  }
+}
+
+/**
+ * Determine the version type (major, minor, or patch) based on semantic versioning rules
+ * Validates the input using semanticVersionSchema before classification
+ *
+ * @param version - The version string to classify
+ * @returns The version type classification
+ * @throws {z.ZodError} If the version string is invalid
+ *
+ * @example
+ * getVersionType('1.0.0') // 'major'
+ * getVersionType('1.2.0') // 'minor'
+ * getVersionType('1.2.3') // 'patch'
+ * getVersionType('1.0') // throws error - must have 3 parts
+ */
+export function getVersionType(version: string): VersionType {
+  // parseSemanticVersion already validates the version
+  const { major, minor, patch } = parseSemanticVersion(version)
+
+  if (major > 0 && minor === 0 && patch === 0) {
+    return "major"
+  }
+  else if (minor > 0 && patch === 0) {
+    return "minor"
+  }
+  else {
+    return "patch"
+  }
+}

package/src/types/column.ts

@@ -0,0 +1,60 @@
+import { z } from "zod"
+
+// Source of truth - can be iterated at runtime
+export const COLUMN_TYPES = ["string", "number", "boolean", "date", "select"] as const
+
+export type ColumnType = (typeof COLUMN_TYPES)[number]
+
+export const selectOptionSchema = z.object({
+  id: z.string(),
+  value: z.string(),
+  color: z.string().regex(/^#[0-9a-f]{6}$/i, "Color must be a valid hex color"),
+})
+
+export const columnConfigSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("string") }),
+  z.object({
+    type: z.literal("number"),
+    decimal: z.number().int().min(0).default(0),
+    format: z.enum(["number", "currency", "percent"]).default("number"),
+  }),
+  z.object({ type: z.literal("boolean") }),
+  z.object({
+    type: z.literal("date"),
+    dateFormat: z.string().optional(),
+  }),
+  z.object({
+    type: z.literal("select"),
+    options: z.array(selectOptionSchema).default([]),
+  }),
+])
+
+export type ColumnConfig = z.infer<typeof columnConfigSchema>
+export type SelectOption = z.infer<typeof selectOptionSchema>
+
+// Column type metadata (label, default config)
+export const COLUMN_TYPE_INFO: Record<
+  ColumnType,
+  { label: string, defaultConfig: ColumnConfig }
+> = {
+  string: { label: "Text", defaultConfig: { type: "string" } },
+  number: {
+    label: "Number",
+    defaultConfig: { type: "number", decimal: 0, format: "number" },
+  },
+  boolean: { label: "Checkbox", defaultConfig: { type: "boolean" } },
+  date: { label: "Date", defaultConfig: { type: "date" } },
+  select: { label: "Select", defaultConfig: { type: "select", options: [] } },
+}
+
+export function isNumberConfig(
+  config: ColumnConfig,
+): config is Extract<ColumnConfig, { type: "number" }> {
+  return config.type === "number"
+}
+
+export function isSelectConfig(
+  config: ColumnConfig,
+): config is Extract<ColumnConfig, { type: "select" }> {
+  return config.type === "select"
+}