@pyreon/connector-document 0.24.4 → 0.24.6

package/src/cssValueParser.ts

@@ -1,110 +0,0 @@
-const PX_RE = /^(-?\d+(?:\.\d+)?)px$/
-const REM_RE = /^(-?\d+(?:\.\d+)?)rem$/
-const EM_RE = /^(-?\d+(?:\.\d+)?)em$/
-const PT_RE = /^(-?\d+(?:\.\d+)?)pt$/
-const NUMBER_RE = /^-?\d+(?:\.\d+)?$/
-
-const DEFAULT_ROOT_SIZE = 16
-
-/**
- * Parse a CSS dimension value to a number.
- *
- * - `14` → `14`
- * - `'14px'` → `14`
- * - `'1.5rem'` → `24` (with rootSize=16)
- * - `'12pt'` → `16` (pt × 1.333)
- * - `'auto'` → `undefined`
- */
-export function parseCssDimension(
-  value: string | number | null | undefined,
-  rootSize = DEFAULT_ROOT_SIZE,
-): number | undefined {
-  if (value == null) return undefined
-  if (typeof value === 'number') return value
-  if (typeof value !== 'string') return undefined
-
-  const trimmed = value.trim()
-
-  const pxMatch = PX_RE.exec(trimmed)
-  if (pxMatch?.[1]) return Number.parseFloat(pxMatch[1])
-
-  const remMatch = REM_RE.exec(trimmed)
-  if (remMatch?.[1]) return Number.parseFloat(remMatch[1]) * rootSize
-
-  const emMatch = EM_RE.exec(trimmed)
-  if (emMatch?.[1]) return Number.parseFloat(emMatch[1]) * rootSize
-
-  const ptMatch = PT_RE.exec(trimmed)
-  if (ptMatch?.[1]) return Number.parseFloat(ptMatch[1]) * (4 / 3)
-
-  if (NUMBER_RE.test(trimmed)) return Number.parseFloat(trimmed)
-
-  return undefined
-}
-
-type BoxModelResult = number | [number, number] | [number, number, number, number] | undefined
-
-/**
- * Parse a CSS padding/margin shorthand to document tuple format.
- *
- * - `8` → `8`
- * - `'8px'` → `8`
- * - `'8px 16px'` → `[8, 16]`
- * - `'8px 16px 8px 16px'` → `[8, 16, 8, 16]`
- * - `'8px 16px 12px'` → `[8, 16, 12, 16]` (CSS 3-value shorthand)
- */
-export function parseBoxModel(
-  value: string | number | undefined,
-  rootSize = DEFAULT_ROOT_SIZE,
-): BoxModelResult {
-  if (value == null) return undefined
-  if (typeof value === 'number') return value
-
-  const parts = value
-    .trim()
-    .split(/\s+/)
-    .map((p) => parseCssDimension(p, rootSize))
-
-  const nums = parts.filter((p): p is number => p != null)
-  if (nums.length !== parts.length) return undefined
-
-  if (nums.length === 1) return nums[0]
-  if (nums.length === 2) return [nums[0], nums[1]] as [number, number]
-  if (nums.length === 3)
-    return [nums[0], nums[1], nums[2], nums[1]] as [number, number, number, number]
-  if (nums.length === 4)
-    return [nums[0], nums[1], nums[2], nums[3]] as [number, number, number, number]
-
-  return undefined
-}
-
-/**
- * Parse a CSS font-weight value.
- */
-export function parseFontWeight(
-  value: string | number | undefined,
-): 'normal' | 'bold' | number | undefined {
-  if (value == null) return undefined
-  if (typeof value === 'number') return value
-  if (value === 'normal' || value === 'bold') return value
-  const num = Number.parseInt(value, 10)
-  if (!Number.isNaN(num)) return num
-  return undefined
-}
-
-/**
- * Parse a CSS line-height value to a unitless number.
- */
-export function parseLineHeight(
-  value: string | number | undefined,
-  rootSize = DEFAULT_ROOT_SIZE,
-): number | undefined {
-  if (value == null) return undefined
-  if (typeof value === 'number') return value
-  if (value === 'normal') return undefined
-
-  const dim = parseCssDimension(value, rootSize)
-  if (dim != null) return dim
-
-  return undefined
-}

package/src/extractDocumentTree.ts

@@ -1,280 +0,0 @@
-import { resolveStyles } from './resolveStyles'
-import type { DocChild, DocNode, NodeType } from './types'
-
-/** Marker interface: components with _documentType are extractable. */
-export interface DocumentMarker {
-  _documentType: NodeType
-}
-
-export interface ExtractOptions {
-  /** Root font size for rem→px conversion. Default: 16. */
-  rootSize?: number
-  /** Include resolved styles from $rocketstyle. Default: true. */
-  includeStyles?: boolean
-}
-
-type VNodeLike = {
-  type: string | ((...args: any[]) => any)
-  props: Record<string, any>
-  children: unknown[]
-}
-
-function isVNode(value: unknown): value is VNodeLike {
-  return value != null && typeof value === 'object' && 'type' in value && 'props' in value
-}
-
-function getDocumentType(fn: unknown): NodeType | undefined {
-  if (typeof fn !== 'function') return undefined
-  const meta = (fn as any).meta
-  if (meta?._documentType) return meta._documentType as NodeType
-  // Fallback: check directly on function (non-rocketstyle components)
-  if ('_documentType' in fn) return (fn as any)._documentType as NodeType
-  return undefined
-}
-
-function flattenChildren(children: unknown[]): unknown[] {
-  const result: unknown[] = []
-  for (const child of children) {
-    if (Array.isArray(child)) {
-      result.push(...flattenChildren(child))
-    } else if (typeof child === 'function') {
-      // Reactive getter — call to resolve
-      const resolved = child()
-      if (Array.isArray(resolved)) {
-        result.push(...flattenChildren(resolved))
-      } else {
-        result.push(resolved)
-      }
-    } else {
-      result.push(child)
-    }
-  }
-  return result
-}
-
-function extractChildren(children: unknown[], options: ExtractOptions): DocChild[] {
-  const flat = flattenChildren(children)
-  const result: DocChild[] = []
-
-  for (const child of flat) {
-    if (child == null || child === false || child === true) continue
-
-    if (typeof child === 'string') {
-      result.push(child)
-      continue
-    }
-
-    if (typeof child === 'number') {
-      result.push(String(child))
-      continue
-    }
-
-    if (isVNode(child)) {
-      const extracted = extractNode(child, options)
-      if (Array.isArray(extracted)) {
-        result.push(...extracted)
-      } else if (extracted != null) {
-        result.push(extracted)
-      }
-    }
-  }
-
-  return result
-}
-
-function extractNode(vnode: VNodeLike, options: ExtractOptions): DocNode | DocChild[] | null {
-  const { type, props, children } = vnode
-  const includeStyles = options.includeStyles !== false
-  const rootSize = options.rootSize ?? 16
-
-  // Component function with _documentType marker (via .statics() or direct)
-  const docType = getDocumentType(type)
-  if (docType) {
-    // ── _documentProps resolution ────────────────────────────────────
-    //
-    // Three paths to find `_documentProps` on a documentType vnode,
-    // tried in order:
-    //
-    //   (A) **Pre-resolved on the JSX vnode itself** — used by test
-    //       fixtures that hand-construct vnodes with `_documentProps`
-    //       baked in. Cheapest path; tried first.
-    //
-    //   (C) **Hoisted-attrs fast path (T3.1, PR #321)** — when the
-    //       component is a real rocketstyle primitive, it exposes
-    //       `__rs_attrs` (the accumulated `.attrs()` callback chain)
-    //       as a typed static. We run the chain DIRECTLY with the
-    //       JSX vnode's props — `chain.reduce(Object.assign, {})` —
-    //       and read `_documentProps` from the result. No styled
-    //       wrapper invocation, no JSX tree creation, no dimension
-    //       resolution. This is the production path for every real
-    //       Pyreon doc-primitive (DocDocument, DocHeading, etc.).
-    //
-    //   (B) **Full component invocation (legacy fallback)** — only
-    //       fires when neither A nor C applies. Used by hand-rolled
-    //       test fixtures that mark a function with `_documentType`
-    //       but don't go through rocketstyle (so `__rs_attrs` is
-    //       absent). Calls the component with the JSX props and
-    //       reads `_documentProps` from the post-call vnode.
-    //
-    // Why three paths instead of one: (A) is for test fixtures that
-    // hardcode `_documentProps` directly on the JSX vnode — a pattern
-    // that pre-dates the attrs HOC. (C) is the real-world path. (B)
-    // is what (C) replaced — kept so non-rocketstyle fixtures still
-    // work. See PR #197 for the original metadata-drop bug and
-    // PR #321 (T3.1) for the architectural fast path.
-    //
-    // **Function values in _documentProps are resolved at this
-    // point** — primitives like DocDocument can store accessor
-    // thunks (`() => string`) for reactive metadata, and the
-    // export pipeline reads the LIVE value on each extraction.
-
-    let rawDocProps: Record<string, unknown> | undefined
-    let extractedFromCall: VNodeLike | null = null
-
-    // Path A: pre-resolved on the JSX vnode (test fixtures)
-    if (props._documentProps && typeof props._documentProps === 'object') {
-      rawDocProps = props._documentProps as Record<string, unknown>
-    } else if (typeof type === 'function') {
-      // ── Path C (T3.1 fast path) ─────────────────────────────────────
-      //
-      // Rocketstyle exposes the accumulated `.attrs()` callback chain
-      // as `__rs_attrs` on the component function. Run the chain
-      // directly with the JSX vnode's props to get the post-attrs
-      // result — no full component invocation, no styling work, no
-      // wrapped JSX tree creation. Just the user-supplied attrs
-      // callback(s) folded into a single props object.
-      //
-      // This eliminates the per-export cost of Path B for every real
-      // rocketstyle primitive (DocDocument, DocHeading, etc.). The
-      // idempotence assumption is now structural rather than implicit:
-      // we never call the component, so it cannot have side effects
-      // that affect the second extraction.
-      const rsAttrs = (type as { __rs_attrs?: Array<(p: Record<string, unknown>) => Record<string, unknown>> }).__rs_attrs
-      if (rsAttrs && rsAttrs.length > 0) {
-        const mergedProps = { ...props }
-        if (children && children.length > 0) {
-          mergedProps.children = children.length === 1 ? children[0] : children
-        }
-        const attrsResult = rsAttrs.reduce<Record<string, unknown>>(
-          (acc, fn) => Object.assign(acc, fn(mergedProps)),
-          {},
-        )
-        if (attrsResult._documentProps && typeof attrsResult._documentProps === 'object') {
-          rawDocProps = attrsResult._documentProps as Record<string, unknown>
-        }
-      } else {
-        // Path B (fallback for non-rocketstyle docComponents):
-        // invoke the component to get the post-attrs vnode. Used by
-        // hand-rolled test fixtures that don't go through rocketstyle.
-        const mergedProps = { ...props }
-        if (children && children.length > 0) {
-          mergedProps.children = children.length === 1 ? children[0] : children
-        }
-        const result = (type as (p: Record<string, unknown>) => unknown)(mergedProps)
-        if (isVNode(result)) {
-          extractedFromCall = result
-          const innerProps = (result as { props?: Record<string, unknown> }).props
-          if (innerProps?._documentProps && typeof innerProps._documentProps === 'object') {
-            rawDocProps = innerProps._documentProps as Record<string, unknown>
-          }
-        }
-      }
-    }
-
-    // Resolve function values (accessors) at extraction time
-    const docProps: Record<string, unknown> = {}
-    if (rawDocProps) {
-      for (const [key, value] of Object.entries(rawDocProps)) {
-        docProps[key] = typeof value === 'function' ? (value as () => unknown)() : value
-      }
-    }
-
-    // Resolve styles from $rocketstyle. Look on the JSX vnode props
-    // first; if the call result has its own $rocketstyle (because the
-    // post-attrs vnode carries it down), use that as a fallback.
-    const stylesSource =
-      props.$rocketstyle ??
-      (extractedFromCall as { props?: Record<string, unknown> } | null)?.props?.$rocketstyle
-    const styles =
-      includeStyles && stylesSource
-        ? resolveStyles(stylesSource as Record<string, unknown>, rootSize)
-        : undefined
-
-    // Children: prefer the JSX vnode's children (the user-supplied
-    // tree). The post-attrs call might wrap children in additional
-    // styled elements that aren't part of the document tree.
-    const docChildren = extractChildren(children ?? [], options)
-
-    const node: DocNode = {
-      type: docType,
-      props: docProps,
-      children: docChildren,
-    }
-
-    if (styles && Object.keys(styles).length > 0) {
-      node.styles = styles
-    }
-
-    return node
-  }
-
-  // Component function WITHOUT _documentType — call it to get its VNode output
-  if (typeof type === 'function') {
-    const mergedProps = { ...props }
-    if (children && children.length > 0) {
-      mergedProps.children = children.length === 1 ? children[0] : children
-    }
-
-    const result = type(mergedProps)
-
-    if (isVNode(result)) {
-      return extractNode(result, options)
-    }
-
-    // The component returned a primitive or null
-    if (typeof result === 'string') return [result]
-    if (typeof result === 'number') return [String(result)]
-    return null
-  }
-
-  // DOM element (string type like 'div', 'span') — transparent, extract children
-  if (typeof type === 'string') {
-    const docChildren = extractChildren(children ?? [], options)
-    // If there's text content in the DOM element, collect it
-    if (docChildren.length > 0) return docChildren
-    return null
-  }
-
-  return null
-}
-
-/**
- * Walk a Pyreon VNode tree and extract a `DocNode` tree for `@pyreon/document`.
- *
- * For each VNode whose component has a `_documentType` marker:
- * 1. Read `_documentType` → `DocNode.type`
- * 2. Read `_documentProps` → `DocNode.props`
- * 3. Read `$rocketstyle` → `resolveStyles()` → `DocNode.styles`
- * 4. Recurse into children
- *
- * VNodes without `_documentType` are transparent — their children
- * are flattened into the parent's children list.
- */
-export function extractDocumentTree(vnode: unknown, options: ExtractOptions = {}): DocNode {
-  if (isVNode(vnode)) {
-    const result = extractNode(vnode, options)
-    if (result && !Array.isArray(result)) return result
-
-    // Wrap loose children in a document node
-    const children = Array.isArray(result) ? result : []
-    return { type: 'document', props: {}, children }
-  }
-
-  // If passed a component function directly, call it
-  if (typeof vnode === 'function') {
-    const result = (vnode as () => unknown)()
-    return extractDocumentTree(result, options)
-  }
-
-  return { type: 'document', props: {}, children: [] }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export {
-  parseBoxModel,
-  parseCssDimension,
-  parseFontWeight,
-  parseLineHeight,
-} from './cssValueParser'
-export type { DocumentMarker, ExtractOptions } from './extractDocumentTree'
-export { extractDocumentTree } from './extractDocumentTree'
-export { resolveStyles } from './resolveStyles'
-export type { DocChild, DocNode, NodeType, ResolvedStyles } from './types'

package/src/resolveStyles.ts

@@ -1,101 +0,0 @@
-import {
-  parseBoxModel,
-  parseCssDimension,
-  parseFontWeight,
-  parseLineHeight,
-} from './cssValueParser'
-import type { ResolvedStyles } from './types'
-
-const TEXT_ALIGN_VALUES = new Set(['left', 'center', 'right', 'justify'])
-const FONT_STYLE_VALUES = new Set(['normal', 'italic'])
-const TEXT_DECORATION_VALUES = new Set(['none', 'underline', 'line-through'])
-const BORDER_STYLE_VALUES = new Set(['solid', 'dashed', 'dotted'])
-
-/**
- * Convert a rocketstyle `$rocketstyle` theme object into a `ResolvedStyles`
- * object compatible with `@pyreon/document`.
- *
- * Only extracts properties that `ResolvedStyles` supports — everything else
- * (transitions, cursor, display, etc.) is silently ignored.
- */
-export function resolveStyles(rocketstyle: Record<string, unknown>, rootSize = 16): ResolvedStyles {
-  const styles: ResolvedStyles = {}
-
-  // Typography
-  const fontSize = parseCssDimension(rocketstyle.fontSize as string | number, rootSize)
-  if (fontSize != null) styles.fontSize = fontSize
-
-  if (typeof rocketstyle.fontFamily === 'string') styles.fontFamily = rocketstyle.fontFamily
-
-  const fontWeight = parseFontWeight(rocketstyle.fontWeight as string | number | undefined)
-  if (fontWeight != null) styles.fontWeight = fontWeight
-
-  if (typeof rocketstyle.fontStyle === 'string' && FONT_STYLE_VALUES.has(rocketstyle.fontStyle))
-    styles.fontStyle = rocketstyle.fontStyle as 'normal' | 'italic'
-
-  if (
-    typeof rocketstyle.textDecoration === 'string' &&
-    TEXT_DECORATION_VALUES.has(rocketstyle.textDecoration)
-  )
-    styles.textDecoration = rocketstyle.textDecoration as 'none' | 'underline' | 'line-through'
-
-  if (typeof rocketstyle.color === 'string') styles.color = rocketstyle.color
-
-  if (typeof rocketstyle.backgroundColor === 'string')
-    styles.backgroundColor = rocketstyle.backgroundColor
-
-  if (typeof rocketstyle.textAlign === 'string' && TEXT_ALIGN_VALUES.has(rocketstyle.textAlign))
-    styles.textAlign = rocketstyle.textAlign as 'left' | 'center' | 'right' | 'justify'
-
-  const lineHeight = parseLineHeight(
-    rocketstyle.lineHeight as string | number | undefined,
-    rootSize,
-  )
-  if (lineHeight != null) styles.lineHeight = lineHeight
-
-  const letterSpacing = parseCssDimension(rocketstyle.letterSpacing as string | number, rootSize)
-  if (letterSpacing != null) styles.letterSpacing = letterSpacing
-
-  // Box model
-  const padding = parseBoxModel(rocketstyle.padding as string | number | undefined, rootSize)
-  if (padding != null) styles.padding = padding
-
-  const margin = parseBoxModel(rocketstyle.margin as string | number | undefined, rootSize)
-  if (margin != null) styles.margin = margin
-
-  // Border
-  const borderRadius = parseCssDimension(rocketstyle.borderRadius as string | number, rootSize)
-  if (borderRadius != null) styles.borderRadius = borderRadius
-
-  const borderWidth = parseCssDimension(rocketstyle.borderWidth as string | number, rootSize)
-  if (borderWidth != null) styles.borderWidth = borderWidth
-
-  if (typeof rocketstyle.borderColor === 'string') styles.borderColor = rocketstyle.borderColor
-
-  if (
-    typeof rocketstyle.borderStyle === 'string' &&
-    BORDER_STYLE_VALUES.has(rocketstyle.borderStyle)
-  )
-    styles.borderStyle = rocketstyle.borderStyle as 'solid' | 'dashed' | 'dotted'
-
-  // Sizing
-  if (rocketstyle.width != null) {
-    const w = parseCssDimension(rocketstyle.width as string | number, rootSize)
-    styles.width = w ?? (rocketstyle.width as string)
-  }
-
-  if (rocketstyle.height != null) {
-    const h = parseCssDimension(rocketstyle.height as string | number, rootSize)
-    styles.height = h ?? (rocketstyle.height as string)
-  }
-
-  if (rocketstyle.maxWidth != null) {
-    const mw = parseCssDimension(rocketstyle.maxWidth as string | number, rootSize)
-    styles.maxWidth = mw ?? (rocketstyle.maxWidth as string)
-  }
-
-  // Opacity
-  if (typeof rocketstyle.opacity === 'number') styles.opacity = rocketstyle.opacity
-
-  return styles
-}

package/src/types.ts

@@ -1 +0,0 @@
-export type { DocChild, DocNode, NodeType, ResolvedStyles } from '@pyreon/document'