murasaki 0.2.0 → 0.3.0

package/src/components/Link.tsx

@@ -1,25 +0,0 @@
-// <Link href="/about">About</Link>
-//
-// Emits a plain <a> tagged with data-murasaki-link. The dev runner injects
-// a tiny script that intercepts clicks on these and switches the visible
-// route block in place — no full reload, no flash.
-
-import { jsx } from '../jsx/runtime.ts'
-import type { Child } from '../jsx/types.ts'
-
-export type LinkProps = {
-  href: string
-  children?: Child
-  className?: string
-  // Pass-through anchor props
-  [key: string]: unknown
-}
-
-export function Link({ href, children, ...rest }: LinkProps) {
-  return jsx('a', {
-    href: `#${href}`,
-    'data-murasaki-link': href,
-    ...rest,
-    children,
-  })
-}

package/src/dev.tsx

@@ -1,60 +0,0 @@
-// src/dev.tsx
-// Murasaki dev runner — Next.js-like file-based routing without Next.js.
-//
-// Reads the consumer's src/ directory:
-//   src/layout.tsx   (optional, can export `metadata`)
-//   src/app.tsx      (required)
-//   src/globals.css  (optional, auto-injected)
-//
-// Renders <Layout><App /></Layout> with React, ships HTML to the WebView,
-// and reloads in place on file change.
-
-import {
-  printBanner,
-  printBye,
-  printOpened,
-  printReady,
-  printShortcuts,
-  printStarting,
-} from './cli/log.ts'
-import { setupHmr } from './runtime/hmr.ts'
-import { setupShortcuts, teardownStdin } from './runtime/shortcuts.ts'
-import {
-  closeWindow,
-  exitApp,
-  getConfig,
-  openWindow,
-  reloadWindow,
-  runApp,
-} from './runtime/window.ts'
-
-const startAt = Date.now()
-
-// Boot: render once (applies metadata) → banner → ready
-await openWindow()
-printBanner(getConfig().title, getConfig())
-printShortcuts()
-printStarting()
-printReady(Date.now() - startAt)
-
-setupShortcuts({
-  onOpen: () => {
-    void openWindow().then(printOpened)
-  },
-  onRestart: () => {
-    closeWindow()
-    void openWindow().then(printOpened)
-  },
-  onQuit: () => {
-    printBye()
-    teardownStdin()
-    exitApp()
-    process.exit(0)
-  },
-})
-
-setupHmr((file) => {
-  void reloadWindow(file)
-})
-
-runApp()

package/src/env.ts

@@ -1,48 +0,0 @@
-// Project paths + version + platform — resolved once at boot.
-
-import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-export const projectRoot = process.cwd()
-export const SRC_DIR = join(projectRoot, 'src')
-
-// App-router convention (new, preferred):
-//   src/app/page.tsx       → "/"
-//   src/app/layout.tsx     → root layout (html/head/body)
-//   src/app/<sub>/page.tsx → "/<sub>"
-//   src/app/globals.css    → auto-injected
-export const APP_DIR = join(SRC_DIR, 'app')
-export const APP_GLOBALS_CSS = join(APP_DIR, 'globals.css')
-
-// Legacy single-page convention (still supported):
-//   src/app.tsx + src/layout.tsx + src/globals.css
-export const LEGACY_APP_PATH = join(SRC_DIR, 'app.tsx')
-export const LEGACY_LAYOUT_PATH = join(SRC_DIR, 'layout.tsx')
-export const LEGACY_GLOBALS_CSS = join(SRC_DIR, 'globals.css')
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-export const VERSION: string = (() => {
-  try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'))
-    return pkg.version || '0.0.0'
-  } catch {
-    return '0.0.0'
-  }
-})()
-
-export const WEBVIEW_ENGINE: string = (() => {
-  switch (process.platform) {
-    case 'darwin':
-      return 'WKWebView (macOS)'
-    case 'win32':
-      return 'WebView2 (Windows)'
-    case 'linux':
-      return 'WebKitGTK (Linux)'
-    default:
-      return `OS native (${process.platform})`
-  }
-})()
-
-export const DEFAULT_WIN_TITLE = 'Murasaki App'
-export const DEFAULT_WIN_SIZE = { width: 1280, height: 800 }

package/src/index.ts

@@ -1,24 +0,0 @@
-// murasaki — public API
-//
-// Import like:
-//   import type { Metadata } from 'murasaki'
-//   import { Link }            from 'murasaki'
-
-export type { LinkProps } from './components/Link.tsx'
-export { Link } from './components/Link.tsx'
-
-export type Metadata = {
-  /** Default <title> for the app (overridden by <title> tag inside <head>) */
-  title?: string
-  /** <meta name="description"> */
-  description?: string
-  /** Initial window options (applied at first open; user can resize after) */
-  window?: {
-    /** Window title bar text (defaults to metadata.title) */
-    title?: string
-    /** Initial width in logical pixels */
-    width?: number
-    /** Initial height in logical pixels */
-    height?: number
-  }
-}

package/src/jsx/index.ts

@@ -1,21 +0,0 @@
-// Public surface for `import { ... } from 'murasaki/jsx'`.
-
-export {
-  createElement,
-  Fragment,
-  isJSXNode,
-  isValidElement,
-  JSXNode,
-  jsx,
-  raw,
-  renderToString,
-} from './runtime.ts'
-
-export type {
-  Child,
-  Component,
-  Element,
-  FC,
-  JSXNodeLike,
-  Props,
-} from './types.ts'

package/src/jsx/jsx-dev-runtime.ts

@@ -1,6 +0,0 @@
-// JSX dev runtime entry — used when tsconfig has `jsx: "react-jsxdev"`.
-// We don't (yet) track source locations or component stacks, so jsxDEV
-// behaves identically to jsx.
-
-export { Fragment, jsx as jsxDEV } from './runtime.ts'
-export type { JSX } from './types.ts'

package/src/jsx/runtime.ts

@@ -1,298 +0,0 @@
-// murasaki/jsx — SSR-only JSX runtime.
-//
-// Inspired by hono/jsx but trimmed for desktop-server use:
-//   - no hooks (the view is rendered once per HMR cycle, no client state)
-//   - no DOM renderer (we ship HTML to the OS WebView and that's it)
-//   - no streaming / Suspense (single render → loadHtml())
-//   - React-compatible enough to swap in for renderToStaticMarkup
-//
-// Two-step pipeline:
-//   1. jsx(tag, props) → JSXNode  (tree)
-//   2. JSXNode.toString() → HTML string
-//
-// User code that runs is the *user's* JSX (transformed to jsx() calls
-// by tsx/esbuild with `jsxImportSource: "murasaki"`).
-
-import type { Child, Component, JSXNodeLike, Props } from './types.ts'
-
-// ── HTML escape ──────────────────────────────────────────────────────
-const AMP = /&/g
-const LT = /</g
-const GT = />/g
-const QT = /"/g
-
-function escapeHtml(s: string): string {
-  return s.replace(AMP, '&amp;').replace(LT, '&lt;').replace(GT, '&gt;')
-}
-
-function escapeAttr(s: string): string {
-  return s.replace(AMP, '&amp;').replace(QT, '&quot;')
-}
-
-// ── Void elements (no closing tag) ────────────────────────────────────
-const VOID_ELEMENTS = new Set([
-  'area',
-  'base',
-  'br',
-  'col',
-  'embed',
-  'hr',
-  'img',
-  'input',
-  'link',
-  'meta',
-  'source',
-  'track',
-  'wbr',
-])
-
-// ── Attribute name normalization (React → HTML) ───────────────────────
-const ATTR_ALIAS: Record<string, string> = {
-  className: 'class',
-  htmlFor: 'for',
-  charSet: 'charset',
-  crossOrigin: 'crossorigin',
-  httpEquiv: 'http-equiv',
-  itemProp: 'itemprop',
-  fetchPriority: 'fetchpriority',
-  noModule: 'nomodule',
-  formAction: 'formaction',
-  acceptCharset: 'accept-charset',
-  autoComplete: 'autocomplete',
-  autoFocus: 'autofocus',
-  autoPlay: 'autoplay',
-  contentEditable: 'contenteditable',
-  defaultValue: 'value',
-  defaultChecked: 'checked',
-  encType: 'enctype',
-  formMethod: 'formmethod',
-  formNoValidate: 'formnovalidate',
-  formTarget: 'formtarget',
-  maxLength: 'maxlength',
-  minLength: 'minlength',
-  noValidate: 'novalidate',
-  readOnly: 'readonly',
-  rowSpan: 'rowspan',
-  colSpan: 'colspan',
-  spellCheck: 'spellcheck',
-  tabIndex: 'tabindex',
-  useMap: 'usemap',
-  srcDoc: 'srcdoc',
-  srcSet: 'srcset',
-  hrefLang: 'hreflang',
-  dateTime: 'datetime',
-  enterKeyHint: 'enterkeyhint',
-  inputMode: 'inputmode',
-}
-
-function normalizeAttrName(k: string): string {
-  return ATTR_ALIAS[k] || k
-}
-
-// ── Style object → CSS string ─────────────────────────────────────────
-function camelToKebab(k: string): string {
-  // Leave already-kebab keys and CSS custom props (--foo) alone.
-  if (k[0] === '-' || !/[A-Z]/.test(k)) return k
-  return k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)
-}
-
-// CSS properties that take unitless numbers (subset of React's list).
-const UNITLESS = new Set([
-  'animationIterationCount',
-  'borderImageOutset',
-  'borderImageSlice',
-  'borderImageWidth',
-  'boxFlex',
-  'boxFlexGroup',
-  'boxOrdinalGroup',
-  'columnCount',
-  'columns',
-  'flex',
-  'flexGrow',
-  'flexShrink',
-  'fontWeight',
-  'gridArea',
-  'gridColumn',
-  'gridColumnEnd',
-  'gridColumnStart',
-  'gridRow',
-  'gridRowEnd',
-  'gridRowStart',
-  'lineClamp',
-  'lineHeight',
-  'opacity',
-  'order',
-  'orphans',
-  'tabSize',
-  'widows',
-  'zIndex',
-  'zoom',
-])
-
-function styleObjToString(obj: Record<string, unknown>): string {
-  let out = ''
-  for (const [k, v] of Object.entries(obj)) {
-    if (v == null || v === false) continue
-    let value: string
-    if (typeof v === 'number') {
-      value = UNITLESS.has(k) ? String(v) : `${v}px`
-    } else if (typeof v === 'string') {
-      value = v
-    } else {
-      continue
-    }
-    out += `${out ? ';' : ''}${camelToKebab(k)}:${value}`
-  }
-  return out
-}
-
-// ── Attribute rendering ──────────────────────────────────────────────
-function renderAttrs(props: Props): string {
-  let out = ''
-  for (const k in props) {
-    if (k === 'children' || k === 'key' || k === 'ref' || k === '__source' || k === '__self')
-      continue
-    const v = props[k]
-    if (v == null || v === false) continue
-
-    const name = normalizeAttrName(k)
-
-    // Boolean attribute
-    if (v === true) {
-      out += ` ${name}`
-      continue
-    }
-
-    // Inline style object
-    if (k === 'style' && typeof v === 'object') {
-      const css = styleObjToString(v as Record<string, unknown>)
-      if (css) out += ` style="${escapeAttr(css)}"`
-      continue
-    }
-
-    // dangerouslySetInnerHTML is handled in JSXNode.toString(), skip here
-    if (k === 'dangerouslySetInnerHTML') continue
-
-    out += ` ${name}="${escapeAttr(String(v))}"`
-  }
-  return out
-}
-
-// ── Raw HTML escape hatch (pre-rendered HTML as a child) ─────────────
-class RawHtml {
-  readonly __isJSXNode = true as const
-  tag = '__raw__'
-  props: Props = {}
-  children: Child[] = []
-  html: string
-  constructor(html: string) {
-    this.html = html
-  }
-  toString(): string {
-    return this.html
-  }
-}
-
-/** Wrap pre-rendered HTML so it's emitted verbatim as a JSX child. */
-export function raw(html: string): JSXNodeLike {
-  return new RawHtml(html)
-}
-
-// ── Children rendering ───────────────────────────────────────────────
-function renderChild(c: Child): string {
-  if (c == null || c === false || c === true) return ''
-  if (typeof c === 'string') return escapeHtml(c)
-  if (typeof c === 'number' || typeof c === 'bigint') return String(c)
-  if (Array.isArray(c)) {
-    let s = ''
-    for (const item of c) s += renderChild(item)
-    return s
-  }
-  if (isJSXNode(c)) return c.toString()
-  return ''
-}
-
-// ── JSXNode ──────────────────────────────────────────────────────────
-export class JSXNode implements JSXNodeLike {
-  readonly __isJSXNode = true as const
-  tag: string | Component
-  props: Props
-  children: Child[]
-
-  constructor(tag: string | Component, props: Props, children: Child[]) {
-    this.tag = tag
-    this.props = props
-    this.children = children
-  }
-
-  toString(): string {
-    const { tag, props, children } = this
-
-    // Fragment / functional component
-    if (typeof tag === 'function') {
-      // Always pass children via props (React-compat)
-      const merged = { ...props, children: children.length === 1 ? children[0] : children }
-      const result = tag(merged)
-      return renderChild(result as Child)
-    }
-
-    // Intrinsic element
-    const attrs = renderAttrs(props)
-
-    // dangerouslySetInnerHTML overrides children
-    const dsi = props.dangerouslySetInnerHTML as { __html?: string } | undefined
-    if (dsi && typeof dsi.__html === 'string') {
-      return `<${tag}${attrs}>${dsi.__html}</${tag}>`
-    }
-
-    if (VOID_ELEMENTS.has(tag)) {
-      // Self-closing for void elements
-      return `<${tag}${attrs}/>`
-    }
-
-    let childHtml = ''
-    for (const c of children) childHtml += renderChild(c)
-
-    return `<${tag}${attrs}>${childHtml}</${tag}>`
-  }
-}
-
-export function isJSXNode(v: unknown): v is JSXNode {
-  return typeof v === 'object' && v !== null && (v as JSXNodeLike).__isJSXNode === true
-}
-
-// ── Public factory (React-compat: createElement / jsx) ────────────────
-export function jsx(
-  tag: string | Component,
-  props: Props | null,
-  ..._restChildren: unknown[]
-): JSXNode {
-  const p = props ?? {}
-  const rawChildren = (p as { children?: Child }).children
-  const children: Child[] = Array.isArray(rawChildren)
-    ? rawChildren
-    : rawChildren != null
-      ? [rawChildren]
-      : []
-  // Strip children from props (it's stored separately)
-  const { children: _drop, ...rest } = p as Props & { children?: Child }
-  return new JSXNode(tag, rest, children)
-}
-
-/** React-compatible alias. */
-export const createElement = jsx
-
-/** Fragment — renders children without a wrapper tag. */
-export function Fragment(props: { children?: Child }): Child {
-  return props.children ?? null
-}
-
-/** Check if something is a JSX element (React.isValidElement compat). */
-export function isValidElement(v: unknown): v is JSXNode {
-  return isJSXNode(v)
-}
-
-/** Convert any value (JSXNode, string, array, etc.) to an HTML string. */
-export function renderToString(value: Child): string {
-  return renderChild(value)
-}

package/src/jsx/types.ts

@@ -1,36 +0,0 @@
-// Public JSX types for murasaki/jsx.
-
-export type Props = Record<string, unknown>
-
-export type Child = string | number | bigint | boolean | null | undefined | JSXNodeLike | Child[]
-
-export interface JSXNodeLike {
-  readonly __isJSXNode: true
-  tag: string | Component
-  props: Props
-  children: Child[]
-  toString(): string
-}
-
-export type Component<P = Props> = (props: P & { children?: Child }) => Child
-
-/** React-compatible alias used by most user code. */
-export type FC<P = Props> = Component<P>
-
-/** For component refs / cloning. */
-export type Element = JSXNodeLike
-
-declare global {
-  namespace JSX {
-    type Element = JSXNodeLike
-    interface ElementChildrenAttribute {
-      children: object
-    }
-    // Loose intrinsic catalog — every HTML/SVG tag accepts any prop.
-    // (Tightening this to a real catalog is a follow-up; keeps the
-    //  runtime usable without bloating the type surface today.)
-    interface IntrinsicElements {
-      [tagName: string]: Record<string, unknown> & { children?: Child }
-    }
-  }
-}

package/src/runtime/hmr.ts

@@ -1,26 +0,0 @@
-// File watcher for src/ — debounces multi-event saves and triggers reload.
-
-import { existsSync, watch } from 'node:fs'
-import { printHint } from '../cli/log.ts'
-import { SRC_DIR } from '../env.ts'
-
-export function setupHmr(onChange: (filename: string) => void): void {
-  if (!existsSync(SRC_DIR)) {
-    printHint('src/ directory not found — nothing to watch')
-    return
-  }
-  let debounce: NodeJS.Timeout | null = null
-  let lastFile = ''
-  try {
-    watch(SRC_DIR, { recursive: true }, (_event, filename) => {
-      if (!filename) return
-      if (debounce) clearTimeout(debounce)
-      lastFile = filename.toString()
-      debounce = setTimeout(() => {
-        onChange(lastFile)
-      }, 80)
-    })
-  } catch (e: any) {
-    printHint(`HMR watcher failed: ${e.message}`)
-  }
-}