zyzz 0.0.0 → 0.0.2

package/src/compiler/internal/Properties.ts

@@ -0,0 +1,121 @@
+/** Validates native property registration descriptors and independent initial values. @module */
+import * as Functions from './Functions.js'
+import * as FunctionSyntax from '../../internal/FunctionSyntax.js'
+import * as Identifiers from './Identifiers.js'
+import * as Tree from 'css-tree'
+
+/** Rejects declaration delimiters inside an authored initial value. */
+export function initial(value: string): void {
+  Tree.parse(value, { context: 'value' })
+}
+
+/** Validates registrations before output-parser recovery can discard them. */
+export function validate(source: string): boolean {
+  let escaped = false
+  Tree.walk(Tree.parse(source), {
+    visit: 'Atrule',
+    enter(rule) {
+      if (rule.name.toLowerCase() !== 'property') return
+      const names = Identifiers.list(
+        rule.prelude ? Tree.generate(rule.prelude) : '',
+        'space',
+      )
+      if (
+        names?.length !== 1 ||
+        !names[0]!.startsWith('--') ||
+        names[0]!.length <= 2 ||
+        !rule.block
+      )
+        throw new Error(
+          'Property registration requires a custom-property name and descriptors.',
+        )
+      const values = new Map<string, Tree.Value>()
+      rule.block.children.forEach((node) => {
+        if (node.type !== 'Declaration' || node.important)
+          throw new Error('Expected non-important property descriptors.')
+        const key = node.property.toLowerCase()
+        if (!['syntax', 'inherits', 'initial-value'].includes(key))
+          throw new Error('Unknown property descriptor.')
+        values.set(
+          key,
+          Tree.parse(Tree.generate(node.value), {
+            context: 'value',
+          }) as Tree.Value,
+        )
+      })
+      const syntaxNode = values.get('syntax')
+      const syntax =
+        syntaxNode?.children.size === 1 &&
+        syntaxNode.children.first?.type === 'String'
+          ? syntaxNode.children.first.value
+          : undefined
+      if (syntax?.includes('\\')) escaped = true
+      const inherits = values.get('inherits')
+      if (
+        syntax === undefined ||
+        !FunctionSyntax.accepts(`type(${syntax})`) ||
+        syntax.includes('<string>')
+      )
+        throw new Error(
+          'Property registration requires a supported syntax string.',
+        )
+      const inherited =
+        inherits && Identifiers.list(Tree.generate(inherits), 'space')
+      if (
+        inherited?.length !== 1 ||
+        !['true', 'false'].includes(inherited[0]!.toLowerCase())
+      )
+        throw new Error('Property registration requires boolean inherits.')
+      const initial = values.get('initial-value')
+      if (!initial && syntax.trim() !== '*')
+        throw new Error(
+          'Non-universal property registrations require an initial value.',
+        )
+      if (!initial || syntax.trim() === '*') return
+      const matched = (() => {
+        try {
+          return Functions.value(syntax, Tree.generate(initial))
+        } catch {
+          throw new Error(
+            'Registered initial values must match the declared syntax.',
+          )
+        }
+      })()
+      if (
+        matched &&
+        (!matched.startsWith('<') || matched.startsWith('<custom-ident>'))
+      )
+        return
+      Tree.walk(initial, (node) => {
+        if (
+          node.type === 'Dimension' &&
+          /^(?:cq(?:w|h|i|b|min|max)|r?(?:em|ex|ch|cap|ic|lh))$/i.test(
+            node.unit,
+          )
+        )
+          throw new Error(
+            'Registered initial values must be computationally independent.',
+          )
+        if (
+          node.type === 'Function' &&
+          /^(?:var|env|attr|light-dark|contrast-color|anchor|anchor-size|sibling-index|sibling-count)$/i.test(
+            Tree.ident.decode(node.name),
+          )
+        )
+          throw new Error(
+            'Registered initial values must be computationally independent.',
+          )
+        if (
+          node.type === 'Identifier' &&
+          /^(?:currentcolor|inherit|initial|unset|revert|revert-layer)$/i.test(
+            Tree.ident.decode(node.name),
+          )
+        )
+          throw new Error(
+            'Registered initial values must be computationally independent.',
+          )
+      })
+    },
+  })
+  return escaped
+}

package/src/compiler/internal/RecipeConditions.ts

@@ -0,0 +1,139 @@
+/** Partitions named recipe queries into mutually exclusive CSS regions. @module */
+import type * as Ast from '@oxc-project/types'
+import * as CssTree from 'css-tree'
+import * as Query from '../../internal/Query.js'
+import * as Themes from './Themes.js'
+
+/** One named condition and its positive/negative grouping rules. */
+export type Condition = {
+  /** Negated query list, represented as an intersection of grouping rules. */
+  readonly inactive: readonly string[]
+  /** Authored name used by the selection callable. */
+  readonly name: string
+  /** Authored value span retained for diagnostics and mapping. */
+  readonly node: Ast.Node
+  /** Resolved positive grouping rule. */
+  readonly rule: string
+}
+
+/** Resolves theme thresholds and derives a logical complement without evaluation. */
+export function read(options: read.Options): Condition {
+  const { name, node } = options
+  if (name === '__proto__')
+    throw new Themes.InvalidError(
+      'Recipe condition names cannot use __proto__.',
+      node,
+    )
+  if (node.type !== 'Literal' || typeof node.value !== 'string')
+    throw new Themes.InvalidError(
+      'Recipe conditions require static media or supports strings.',
+      node,
+    )
+
+  try {
+    const rule = Query.resolve(
+      node.value,
+      options.queries ?? {
+        breakpoints: {},
+        containerNames: [],
+        containers: {},
+      },
+    )
+    const match = /^@(media|supports)(?=[\s(])\s*([\s\S]+)$/.exec(
+      rule.replace(/\/\*[\s\S]*?\*\//g, ' '),
+    )
+    if (!match)
+      throw new Error('Recipe conditions support only @media and @supports.')
+
+    const text = match[2]!
+    if (match[1] === 'supports') {
+      // Parse the complete rule so malformed braces or trailing rules cannot
+      // become part of a synthesized condition.
+      const parsed = CssTree.parse(`@supports ${text}{}`)
+      if (parsed.type !== 'StyleSheet' || parsed.children.size !== 1)
+        throw new Error('Malformed supports condition.')
+      const entry = parsed.children.first
+      if (
+        entry?.type !== 'Atrule' ||
+        !entry.prelude ||
+        !entry.block ||
+        !entry.block.children.isEmpty
+      )
+        throw new Error('Malformed supports condition.')
+      CssTree.walk(entry.prelude, (node) => {
+        if (node.type === 'Raw')
+          throw new Error('Malformed supports condition.')
+      })
+      return { inactive: [`@supports not (${text})`], name, node, rule }
+    }
+
+    const list = CssTree.parse(text, { context: 'mediaQueryList' })
+    if (list.type !== 'MediaQueryList' || list.children.isEmpty)
+      throw new Error('Malformed media condition.')
+    const inactive = list.children.toArray().map((query) => {
+      if (query.type !== 'MediaQuery')
+        throw new Error('Malformed media condition.')
+      if (query.mediaType)
+        return `@media ${CssTree.generate({ ...query, modifier: query.modifier?.toLowerCase() === 'not' ? null : 'not' })}`
+      if (!query.condition) throw new Error('Malformed media condition.')
+      return `@media not (${CssTree.generate(query.condition)})`
+    })
+    return { inactive, name, node, rule }
+  } catch (error) {
+    throw new Themes.InvalidError(
+      error instanceof Error ? error.message : 'Invalid recipe condition.',
+      node,
+    )
+  }
+}
+
+/** Inputs for static condition resolution. */
+export declare namespace read {
+  /** Named condition and optional bound query metadata. */
+  type Options = {
+    /** Author-facing condition name. */
+    readonly name: string
+    /** Literal query source. */
+    readonly node: Ast.Node
+    /** Theme-owned query thresholds. */
+    readonly queries?: Query.Metadata | undefined
+  }
+}
+
+/** One satisfiable candidate truth region; CSS discards impossible intersections. */
+export type Region = {
+  /** Active condition indexes in authored priority order. */
+  readonly active: readonly number[]
+  /** Nested grouping rules defining this region. */
+  readonly rules: readonly { readonly node: Ast.Node; readonly rule: string }[]
+}
+
+/** Enumerates only condition states, never combinations of axis choices. */
+export function regions(conditions: readonly Condition[]): readonly Region[] {
+  // A compile-time ceiling bounds generated output before allocating regions.
+  if (conditions.length > 8)
+    throw new Themes.InvalidError(
+      'Recipes support at most eight named conditions (256 CSS regions).',
+      conditions[8]!.node,
+    )
+
+  let result: readonly Region[] = [{ active: [], rules: [] }]
+  for (const [index, condition] of conditions.entries())
+    result = result.flatMap((region) => [
+      {
+        active: region.active,
+        rules: [
+          ...region.rules,
+          ...condition.inactive.map((rule) => ({ node: condition.node, rule })),
+        ],
+      },
+      {
+        active: [...region.active, index],
+        rules: [
+          ...region.rules,
+          { node: condition.node, rule: condition.rule },
+        ],
+      },
+    ])
+  return result
+}

package/src/compiler/internal/RecipePayloads.ts

@@ -0,0 +1,132 @@
+/** Reuses typed callback extraction for isolated recipe payload contexts. @module */
+import type * as Ast from '@oxc-project/types'
+import * as Walker from 'oxc-walker'
+import type * as Binding from '../../internal/Binding.js'
+import * as Dynamic from './Dynamic.js'
+import * as Expression from './Expression.js'
+
+/** Shared callback validation and lookup boundary consumed by source extraction. */
+export type Bindings = Pick<
+  NonNullable<ReturnType<typeof Dynamic.read>>,
+  'accepts' | 'resolve' | 'slots'
+>
+
+/** Collects isolated bindings without evaluating any author callback. */
+export function create(options: create.Options) {
+  const references = new WeakMap<Ast.Node, Binding.Reference>()
+  const owners = new Map<
+    Binding.Reference,
+    NonNullable<ReturnType<typeof Dynamic.read>>
+  >()
+  const slots: Record<string, Binding.Reference> = Object.create(null)
+
+  return {
+    accepts(reference: Binding.Reference, property: string) {
+      return owners.get(reference)?.accepts(reference, property) ?? false
+    },
+    read(node: Ast.Node, identity: string) {
+      const model = Dynamic.read(
+        structuredClone(node),
+        identity,
+        options.resolveType,
+      )
+      if (!model) return undefined
+      const body = options.normalize(model.body) as Ast.ObjectExpression
+      Walker.walk(body, {
+        enter(node) {
+          const slot = model.resolve(node)
+          if (slot) references.set(Expression.unwrap(node), slot)
+        },
+      })
+      for (const slot of Object.values(model.slots)) {
+        owners.set(slot, model)
+        slots[slot.name] = slot
+      }
+      return {
+        ...model,
+        body,
+        acceptsValue(field: string, value: string | number) {
+          const type = options.resolveType(model.type)
+          if (type.type !== 'TSTypeLiteral') return false
+          const member = type.members.find(
+            (member) =>
+              member.type === 'TSPropertySignature' &&
+              (member.key.type === 'Identifier'
+                ? member.key.name
+                : member.key.type === 'Literal'
+                  ? member.key.value
+                  : undefined) === field,
+          )
+          return (
+            member?.type === 'TSPropertySignature' &&
+            member.typeAnnotation != null &&
+            accepts(
+              options.resolveType(member.typeAnnotation.typeAnnotation),
+              value,
+            )
+          )
+        },
+      }
+    },
+    resolve(node: Ast.Node) {
+      return references.get(Expression.unwrap(node))
+    },
+    slots,
+  }
+}
+
+/** Source-owned static resolution hooks. */
+export declare namespace create {
+  /** Compiler adapters used for the same resolution as dynamic style callbacks. */
+  type Options = {
+    /** Expands immutable body data without executing expressions. */
+    readonly normalize: (node: Ast.Node) => Ast.Node
+    /** Resolves finite local or imported callback type aliases. */
+    readonly resolveType: (node: Ast.Node) => Ast.Node
+  }
+}
+
+function accepts(node: Ast.Node, value: string | number): boolean {
+  if (node.type === 'TSUnionType')
+    return node.types.some((node) => accepts(node, value))
+  if (node.type === 'TSIntersectionType')
+    return node.types.every((node) => accepts(node, value))
+  if (node.type === 'TSStringKeyword') return typeof value === 'string'
+  if (node.type === 'TSNumberKeyword')
+    return typeof value === 'number' && Number.isFinite(value)
+  if (node.type === 'TSLiteralType') {
+    if (node.literal.type === 'Literal') return node.literal.value === value
+    if (
+      node.literal.type === 'UnaryExpression' &&
+      node.literal.operator === '-' &&
+      node.literal.argument.type === 'Literal' &&
+      typeof node.literal.argument.value === 'number'
+    )
+      return -node.literal.argument.value === value
+  }
+  if (node.type === 'TSTemplateLiteralType' && typeof value === 'string') {
+    const template = node
+    const input = value
+    function match(index: number, offset: number): boolean {
+      const text =
+        template.quasis[index]!.value.cooked ??
+        template.quasis[index]!.value.raw
+      if (!input.startsWith(text, offset)) return false
+      offset += text.length
+      if (index === template.types.length) return offset === input.length
+      for (let end = offset; end <= input.length; end++) {
+        const part = input.slice(offset, end)
+        const type = template.types[index]!
+        const valid =
+          accepts(type, part) ||
+          (part.trim() !== '' &&
+            Number.isFinite(Number(part)) &&
+            accepts(type, Number(part)))
+        if (valid && match(index + 1, end)) return true
+      }
+      return false
+    }
+    return match(0, 0)
+  }
+  return false
+}