@stravigor/core 0.1.0

package/src/storage/upload.ts

@@ -0,0 +1,91 @@
+import Storage from './storage.ts'
+import { StravError } from '../exceptions/strav_error.ts'
+
+export class FileTooLargeError extends StravError {}
+
+export class InvalidFileTypeError extends StravError {}
+
+export interface UploadResult {
+  path: string
+  url: string
+}
+
+const SIZE_UNITS: Record<string, number> = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+}
+
+/**
+ * Fluent file upload builder with validation.
+ *
+ * @example
+ * const { path, url } = await Upload.file(avatar)
+ *   .maxSize('5mb')
+ *   .types(['image/jpeg', 'image/png'])
+ *   .store('avatars')
+ */
+export class Upload {
+  private _maxSizeBytes?: number
+  private _allowedTypes?: string[]
+
+  private constructor(private _file: File) {}
+
+  /** Start an upload pipeline. */
+  static file(file: File): Upload {
+    return new Upload(file)
+  }
+
+  /** Set maximum file size (e.g. '5mb', '500kb', '1gb', or bytes as number). */
+  maxSize(size: string | number): this {
+    this._maxSizeBytes = typeof size === 'number' ? size : parseSize(size)
+    return this
+  }
+
+  /** Set allowed MIME types. */
+  types(types: string[]): this {
+    this._allowedTypes = types
+    return this
+  }
+
+  /** Validate and store the file. */
+  async store(directory: string, name?: string): Promise<UploadResult> {
+    this.validate()
+
+    const path = name
+      ? await Storage.putAs(directory, this._file, name)
+      : await Storage.put(directory, this._file)
+
+    const url = Storage.url(path)
+
+    return { path, url }
+  }
+
+  private validate(): void {
+    if (this._maxSizeBytes !== undefined && this._file.size > this._maxSizeBytes) {
+      throw new FileTooLargeError(
+        `File size ${formatBytes(this._file.size)} exceeds maximum ${formatBytes(this._maxSizeBytes)}`
+      )
+    }
+
+    if (this._allowedTypes && !this._allowedTypes.includes(this._file.type)) {
+      throw new InvalidFileTypeError(
+        `File type "${this._file.type}" not allowed. Allowed: ${this._allowedTypes.join(', ')}`
+      )
+    }
+  }
+}
+
+function parseSize(size: string): number {
+  const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)$/)
+  if (!match) throw new Error(`Invalid size format: "${size}". Use e.g. '5mb', '500kb', '1gb'`)
+  return parseFloat(match[1]!) * SIZE_UNITS[match[2]!]!
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`
+}

package/src/validation/index.ts

@@ -0,0 +1,18 @@
+export { validate } from './validate.ts'
+export {
+  required,
+  string,
+  integer,
+  number,
+  boolean,
+  min,
+  max,
+  email,
+  url,
+  regex,
+  enumOf,
+  oneOf,
+  array,
+} from './rules.ts'
+export type { Rule } from './rules.ts'
+export type { RuleSet, ValidationResult } from './validate.ts'

package/src/validation/rules.ts

@@ -0,0 +1,170 @@
+import { t } from '../i18n/helpers.ts'
+
+export interface Rule {
+  name: string
+  validate(value: unknown): string | null
+}
+
+export function required(): Rule {
+  return {
+    name: 'required',
+    validate(value) {
+      if (value === undefined || value === null || value === '') {
+        return t('validation.required')
+      }
+      return null
+    },
+  }
+}
+
+export function string(): Rule {
+  return {
+    name: 'string',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'string') return t('validation.string')
+      return null
+    },
+  }
+}
+
+export function integer(): Rule {
+  return {
+    name: 'integer',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'number' || !Number.isInteger(value)) return t('validation.integer')
+      return null
+    },
+  }
+}
+
+export function number(): Rule {
+  return {
+    name: 'number',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'number' || isNaN(value)) return t('validation.number')
+      return null
+    },
+  }
+}
+
+export function boolean(): Rule {
+  return {
+    name: 'boolean',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'boolean') return t('validation.boolean')
+      return null
+    },
+  }
+}
+
+export function min(n: number): Rule {
+  return {
+    name: 'min',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value === 'number') {
+        if (value < n) return t('validation.min.number', { min: n })
+      } else if (typeof value === 'string') {
+        if (value.length < n) return t('validation.min.string', { min: n })
+      }
+      return null
+    },
+  }
+}
+
+export function max(n: number): Rule {
+  return {
+    name: 'max',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value === 'number') {
+        if (value > n) return t('validation.max.number', { max: n })
+      } else if (typeof value === 'string') {
+        if (value.length > n) return t('validation.max.string', { max: n })
+      }
+      return null
+    },
+  }
+}
+
+export function email(): Rule {
+  return {
+    name: 'email',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'string') return t('validation.string')
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return t('validation.email')
+      return null
+    },
+  }
+}
+
+export function url(): Rule {
+  return {
+    name: 'url',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'string') return t('validation.string')
+      try {
+        new URL(value)
+        return null
+      } catch {
+        return t('validation.url')
+      }
+    },
+  }
+}
+
+export function regex(pattern: RegExp): Rule {
+  return {
+    name: 'regex',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (typeof value !== 'string') return t('validation.string')
+      if (!pattern.test(value)) return t('validation.regex')
+      return null
+    },
+  }
+}
+
+export function enumOf(enumObj: Record<string, string | number>): Rule {
+  const values = Object.values(enumObj)
+  return {
+    name: 'enumOf',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (!values.includes(value as any)) {
+        return t('validation.enum', { values: values.join(', ') })
+      }
+      return null
+    },
+  }
+}
+
+export function oneOf(values: readonly (string | number | boolean)[]): Rule {
+  return {
+    name: 'oneOf',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (!values.includes(value as any)) {
+        return t('validation.enum', { values: values.join(', ') })
+      }
+      return null
+    },
+  }
+}
+
+export function array(): Rule {
+  return {
+    name: 'array',
+    validate(value) {
+      if (value === undefined || value === null) return null
+      if (!Array.isArray(value)) return t('validation.array')
+      return null
+    },
+  }
+}

package/src/validation/validate.ts

@@ -0,0 +1,41 @@
+import type { Rule } from './rules.ts'
+
+export type RuleSet = Record<string, Rule[]>
+
+export interface ValidationResult<T = Record<string, unknown>> {
+  data: T
+  errors: Record<string, string[]> | null
+}
+
+export function validate<T = Record<string, unknown>>(
+  input: unknown,
+  rules: RuleSet
+): ValidationResult<T> {
+  const record = (typeof input === 'object' && input !== null ? input : {}) as Record<
+    string,
+    unknown
+  >
+  const data: Record<string, unknown> = {}
+  const errors: Record<string, string[]> = {}
+  let hasErrors = false
+
+  for (const [field, fieldRules] of Object.entries(rules)) {
+    const value = record[field]
+    if (value !== undefined) data[field] = value
+
+    for (const rule of fieldRules) {
+      const error = rule.validate(value)
+      if (error) {
+        if (!errors[field]) errors[field] = []
+        errors[field]!.push(error)
+        hasErrors = true
+        break // stop at first error per field
+      }
+    }
+  }
+
+  return {
+    data: data as T,
+    errors: hasErrors ? errors : null,
+  }
+}

package/src/view/cache.ts

@@ -0,0 +1,47 @@
+export interface RenderResult {
+  output: string
+  blocks: Record<string, string>
+}
+
+export type RenderFunction = (
+  data: Record<string, unknown>,
+  includeFn: IncludeFn
+) => Promise<RenderResult>
+
+export type IncludeFn = (name: string, data: Record<string, unknown>) => Promise<string>
+
+export interface CacheEntry {
+  fn: RenderFunction
+  layout?: string
+  mtime: number
+  filePath: string
+}
+
+export default class TemplateCache {
+  private entries = new Map<string, CacheEntry>()
+
+  get(name: string): CacheEntry | undefined {
+    return this.entries.get(name)
+  }
+
+  set(name: string, entry: CacheEntry): void {
+    this.entries.set(name, entry)
+  }
+
+  async isStale(name: string): Promise<boolean> {
+    const entry = this.entries.get(name)
+    if (!entry) return true
+    const file = Bun.file(entry.filePath)
+    const exists = await file.exists()
+    if (!exists) return true
+    return file.lastModified > entry.mtime
+  }
+
+  delete(name: string): void {
+    this.entries.delete(name)
+  }
+
+  clear(): void {
+    this.entries.clear()
+  }
+}

package/src/view/client/islands.ts

@@ -0,0 +1,50 @@
+// @ts-nocheck — Client-side script; requires DOM types provided by the app's bundler config.
+/**
+ * Vue Islands Bootstrap
+ *
+ * Auto-discovers elements with [data-vue] attributes and mounts
+ * Vue components on them. Register your components on the window
+ * before this script runs:
+ *
+ *   import Counter from './components/Counter.vue'
+ *   window.__vue_components = { counter: Counter }
+ *
+ * Then in your .strav templates:
+ *   <vue:counter :initial="{{ count }}" label="Click me" />
+ */
+
+import { createApp } from 'vue'
+
+declare global {
+  interface Window {
+    __vue_components?: Record<string, any>
+  }
+}
+
+function toPascalCase(str: string): string {
+  return str.replace(/(^|-)(\w)/g, (_match, _sep, char) => char.toUpperCase())
+}
+
+function mountIslands(): void {
+  const components = window.__vue_components ?? {}
+
+  document.querySelectorAll<HTMLElement>('[data-vue]').forEach(el => {
+    const name = el.dataset.vue
+    if (!name) return
+
+    const Component = components[name] ?? components[toPascalCase(name)]
+    if (!Component) {
+      console.warn(`[islands] Unknown component: ${name}`)
+      return
+    }
+
+    const props = JSON.parse(el.dataset.props ?? '{}')
+    createApp(Component, props).mount(el)
+  })
+}
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', mountIslands)
+} else {
+  mountIslands()
+}

package/src/view/compiler.ts

@@ -0,0 +1,185 @@
+import { TemplateError } from '../exceptions/errors.ts'
+import type { Token } from './tokenizer.ts'
+
+export interface CompilationResult {
+  code: string
+  layout?: string
+}
+
+interface StackEntry {
+  type: 'if' | 'each' | 'block'
+  line: number
+}
+
+function escapeJs(str: string): string {
+  return str
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t')
+}
+
+export function compile(tokens: Token[]): CompilationResult {
+  const lines: string[] = []
+  const stack: StackEntry[] = []
+  let layout: string | undefined
+
+  lines.push('let __out = "";')
+  lines.push('const __blocks = {};')
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case 'text':
+        lines.push(`__out += "${escapeJs(token.value)}";`)
+        break
+
+      case 'escaped':
+        lines.push(`__out += __escape(${token.value});`)
+        break
+
+      case 'raw':
+        lines.push(`__out += (${token.value});`)
+        break
+
+      case 'comment':
+        // Stripped from output
+        break
+
+      case 'vue_island': {
+        const attrs = token.attrs ?? {}
+        const propParts: string[] = []
+        for (const [name, attr] of Object.entries(attrs)) {
+          if (attr.bound) {
+            propParts.push(`${JSON.stringify(name)}: (${attr.value})`)
+          } else {
+            propParts.push(`${JSON.stringify(name)}: ${JSON.stringify(attr.value)}`)
+          }
+        }
+        const propsExpr = `{${propParts.join(', ')}}`
+        const tag = escapeJs(token.tag!)
+        lines.push('__out += \'<div data-vue="' + tag + '"\'')
+        lines.push('  + " data-props=\'" + JSON.stringify(' + propsExpr + ') + "\'"')
+        lines.push("  + '></div>';")
+
+        break
+      }
+
+      case 'directive':
+        compileDirective(token, lines, stack, l => {
+          layout = l
+        })
+        break
+    }
+  }
+
+  if (stack.length > 0) {
+    const unclosed = stack[stack.length - 1]!
+    throw new TemplateError(`Unclosed @${unclosed.type} block (opened at line ${unclosed.line})`)
+  }
+
+  lines.push('return { output: __out, blocks: __blocks };')
+
+  return { code: lines.join('\n'), layout }
+}
+
+function compileDirective(
+  token: Token,
+  lines: string[],
+  stack: StackEntry[],
+  setLayout: (name: string) => void
+): void {
+  switch (token.directive) {
+    case 'if':
+      if (!token.args) throw new TemplateError(`@if requires a condition at line ${token.line}`)
+      lines.push(`if (${token.args}) {`)
+      stack.push({ type: 'if', line: token.line })
+      break
+
+    case 'elseif':
+      if (!token.args) throw new TemplateError(`@elseif requires a condition at line ${token.line}`)
+      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
+        throw new TemplateError(`@elseif without matching @if at line ${token.line}`)
+      }
+      lines.push(`} else if (${token.args}) {`)
+      break
+
+    case 'else':
+      if (!stack.length || stack[stack.length - 1]!.type !== 'if') {
+        throw new TemplateError(`@else without matching @if at line ${token.line}`)
+      }
+      lines.push(`} else {`)
+      break
+
+    case 'each': {
+      if (!token.args) throw new TemplateError(`@each requires arguments at line ${token.line}`)
+      const match = token.args.match(/^\s*(\w+)\s+in\s+(.+)$/)
+      if (!match) {
+        throw new TemplateError(`@each syntax error at line ${token.line}: expected "item in list"`)
+      }
+      const itemName = match[1]!
+      const listExpr = match[2]!.trim()
+      lines.push(`{`)
+      lines.push(`  const __list = (${listExpr});`)
+      lines.push(`  for (let $index = 0; $index < __list.length; $index++) {`)
+      lines.push(`    const ${itemName} = __list[$index];`)
+      lines.push(`    const $first = $index === 0;`)
+      lines.push(`    const $last = $index === __list.length - 1;`)
+      stack.push({ type: 'each', line: token.line })
+      break
+    }
+
+    case 'layout': {
+      if (!token.args) throw new TemplateError(`@layout requires a name at line ${token.line}`)
+      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
+      setLayout(name)
+      break
+    }
+
+    case 'block': {
+      if (!token.args) throw new TemplateError(`@block requires a name at line ${token.line}`)
+      const name = token.args.replace(/^['"]|['"]$/g, '').trim()
+      lines.push(`__blocks[${JSON.stringify(name)}] = (function() { let __out = "";`)
+      stack.push({ type: 'block', line: token.line })
+      break
+    }
+
+    case 'include': {
+      if (!token.args) throw new TemplateError(`@include requires arguments at line ${token.line}`)
+      const match = token.args.match(/^\s*['"]([^'"]+)['"]\s*(?:,\s*(.+))?\s*$/)
+      if (!match) {
+        throw new TemplateError(
+          `@include syntax error at line ${token.line}: expected "'name'" or "'name', data"`
+        )
+      }
+      const name = match[1]!
+      const dataExpr = match[2] ? match[2].trim() : '{}'
+      lines.push(`__out += await __include(${JSON.stringify(name)}, ${dataExpr});`)
+      break
+    }
+
+    case 'islands': {
+      const src = token.args
+        ? token.args.replace(/^['"]|['"]$/g, '').trim()
+        : '/islands.js'
+      lines.push(`__out += '<script src="${escapeJs(src)}"><\\/script>';`)
+      break
+    }
+
+    case 'end': {
+      if (!stack.length) {
+        throw new TemplateError(`Unexpected @end at line ${token.line} — no open block`)
+      }
+      const top = stack.pop()!
+      if (top.type === 'block') {
+        lines.push(`return __out; })();`)
+      } else if (top.type === 'each') {
+        lines.push(`  }`) // close for loop
+        lines.push(`}`) // close block scope
+      } else {
+        lines.push(`}`)
+      }
+      break
+    }
+  }
+}