zyzz 0.0.28 → 0.0.29

package/src/compiler/internal/Properties.ts

@@ -1,121 +0,0 @@
-/** 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

@@ -1,139 +0,0 @@
-/** 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 ?? {
-        breakpoint: {},
-        containerNames: [],
-        container: {},
-      },
-    )
-    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

@@ -1,132 +0,0 @@
-/** 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
-}