zyzz 0.0.0 → 0.0.2

package/src/internal/Grid.ts

@@ -0,0 +1,67 @@
+/** Describes static grid placement constraints. @module */
+import type * as Numeric from './Numeric.js'
+
+/** Refines numeric line indexes and span counts without parsing custom names or math arguments. */
+export type Checked<
+  value,
+  items extends number = 1,
+> = value extends readonly unknown[]
+  ? { [key in keyof value]: Checked<value[key], items> }
+  : value extends number
+    ? Count<value, false>
+    : value extends `${infer body} !important`
+      ? Checked<Trim<body>, items> extends never
+        ? never
+        : value
+      : value extends string
+        ? value extends `${string}(${string}`
+          ? value
+          : Lines<value, items> extends never
+            ? never
+            : value
+        : value
+
+type Lines<
+  text extends string,
+  items extends number,
+  count extends readonly unknown[] = [0],
+> = text extends `${infer before}/${infer after}`
+  ? count['length'] extends items
+    ? never
+    : Checked<before> extends never
+      ? never
+      : Lines<after, items, readonly [...count, 0]>
+  : Words<text, ` ${text} ` extends `${string} span ${string}` ? true : false>
+
+type Words<
+  text extends string,
+  span extends boolean,
+> = text extends `${infer first} ${infer rest}`
+  ? Word<first, span> extends never
+    ? never
+    : Words<rest, span>
+  : Word<text, span>
+
+type Word<text extends string, span extends boolean> = [
+  Numeric.Parse<text>,
+] extends [never]
+  ? text extends `${number}`
+    ? never
+    : text
+  : Count<text, span>
+
+type Count<value extends string | number, span extends boolean> =
+  Numeric.Checked<value, true> extends never
+    ? never
+    : Numeric.Zero<value> extends true
+      ? never
+      : span extends true
+        ? `${value}` extends `-${string}`
+          ? never
+          : value
+        : value
+
+type Trim<value extends string> =
+  value extends `${infer body}${' ' | '\n' | '\r' | '\t' | '\f'}`
+    ? Trim<body>
+    : value

package/src/internal/Identifier.ts

@@ -0,0 +1,14 @@
+/** Describes property value domains. @module */
+/** Property-specific name grammar; quoted and escaped spellings remain separate. */
+export type Options = {
+  /** Whether custom names must begin with two hyphens. */
+  readonly dashed?: boolean
+  /** Additional reserved words excluded case-insensitively. */
+  readonly excluded?: readonly string[]
+  /** Literal keywords that are valid in this property. */
+  readonly keywords: readonly string[]
+  /** Separator for multi-name values; omission permits one name. */
+  readonly separator?: 'comma' | 'space'
+  /** Keywords that cannot occur alongside another list component. */
+  readonly standalone?: readonly string[]
+}

package/src/internal/Identity.ts

@@ -0,0 +1,89 @@
+/** Derives portable identifiers without source locations or process-global counters. @module */
+import * as Binding from './Binding.js'
+import * as Token from './Token.js'
+import type * as Style from '../Style.js'
+
+/** Encodes an explicit identity without losing punctuation or Unicode distinctions. */
+export function encode(value: string): string {
+  return Array.from(value, (character) =>
+    character.codePointAt(0)!.toString(16),
+  ).join('-')
+}
+
+/** Requires an explicit identity at an uncompiled authoring boundary. */
+export function requireId(id: string | undefined, kind: string): string {
+  if (!id)
+    throw new Error(
+      `${kind} requires an explicit id without the compiler plugin.`,
+    )
+  return `id-${encode(id)}`
+}
+
+/** Names one callback input independently of its declaration order. */
+export function slot(id: string, field: string): `--${string}` {
+  return `--z-d${id}-${encode(field)}`
+}
+
+/** Hashes a canonical value using two independent 32-bit accumulators. */
+export function hash(value: string): string {
+  let a = 2166136261
+  let b = 5381
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index)
+    a = Math.imul(a ^ code, 16777619)
+    b = Math.imul(b, 33) ^ code
+  }
+  return `${(a >>> 0).toString(36)}${(b >>> 0).toString(36)}`
+}
+
+/** Names ordered style data consistently in runtime and extraction. */
+export function style(input: Style.NamedStyle): string {
+  function value(input: Style.Declaration['value']): unknown {
+    if (Binding.is(input)) return ['variable', input.name]
+    if (Token.is(input))
+      return ['token', input.contract[Token.identity], input.path, input.value]
+    if (Token.isExpression(input))
+      return [
+        'expression',
+        input.parts.map((part) =>
+          typeof part === 'string' ? part : value(part),
+        ),
+      ]
+    return input
+  }
+  function shape(style: Style.NamedStyle): unknown {
+    if (style.targets) {
+      const { targets, ...shared } = style
+      return [
+        shape(shared),
+        targets.native ?? null,
+        targets.ios ?? null,
+        targets.android ?? null,
+        targets.web ? shape(targets.web) : null,
+      ]
+    }
+    if (style.rules)
+      return style.rules.map((rule) => [
+        rule.condition ?? '',
+        shape(rule.style),
+      ])
+    return style.declarations.map((declaration) => [
+      declaration.property,
+      value(declaration.value),
+      !!declaration.important,
+    ])
+  }
+  return `z-content-${hash(JSON.stringify(shape(input)))}`
+}
+
+/** Names a complete ordered composition, including repeated definitions. */
+export function composition(names: readonly string[]): string {
+  return `z-compose-${hash(JSON.stringify(names))}`
+}
+
+/** Names a stylesheet declaration with a caller-owned identity. */
+export function contribution(kind: string, id: string | undefined): string {
+  const identity = requireId(id, kind)
+  if (kind === 'keyframes') return `z-k${identity}`
+  return `${kind === 'counterStyle' ? '' : '--'}z-${kind.toLowerCase()}${identity}`
+}

package/src/internal/Lexical.ts

@@ -0,0 +1,202 @@
+/** Normalizes CSS token spellings for static contracts and literal precedence. @module */
+import type * as Numeric from './Numeric.js'
+
+type Ascii = {
+  readonly '30': '0'
+  readonly '31': '1'
+  readonly '32': '2'
+  readonly '33': '3'
+  readonly '34': '4'
+  readonly '35': '5'
+  readonly '36': '6'
+  readonly '37': '7'
+  readonly '38': '8'
+  readonly '39': '9'
+  readonly '41': 'A'
+  readonly '42': 'B'
+  readonly '43': 'C'
+  readonly '44': 'D'
+  readonly '45': 'E'
+  readonly '46': 'F'
+  readonly '47': 'G'
+  readonly '48': 'H'
+  readonly '49': 'I'
+  readonly '4a': 'J'
+  readonly '4b': 'K'
+  readonly '4c': 'L'
+  readonly '4d': 'M'
+  readonly '4e': 'N'
+  readonly '4f': 'O'
+  readonly '50': 'P'
+  readonly '51': 'Q'
+  readonly '52': 'R'
+  readonly '53': 'S'
+  readonly '54': 'T'
+  readonly '55': 'U'
+  readonly '56': 'V'
+  readonly '57': 'W'
+  readonly '58': 'X'
+  readonly '59': 'Y'
+  readonly '5a': 'Z'
+  readonly '61': 'a'
+  readonly '62': 'b'
+  readonly '63': 'c'
+  readonly '64': 'd'
+  readonly '65': 'e'
+  readonly '66': 'f'
+  readonly '67': 'g'
+  readonly '68': 'h'
+  readonly '69': 'i'
+  readonly '6a': 'j'
+  readonly '6b': 'k'
+  readonly '6c': 'l'
+  readonly '6d': 'm'
+  readonly '6e': 'n'
+  readonly '6f': 'o'
+  readonly '70': 'p'
+  readonly '71': 'q'
+  readonly '72': 'r'
+  readonly '73': 's'
+  readonly '74': 't'
+  readonly '75': 'u'
+  readonly '76': 'v'
+  readonly '77': 'w'
+  readonly '78': 'x'
+  readonly '79': 'y'
+  readonly '7a': 'z'
+  readonly '5f': '_'
+  readonly '2d': '-'
+}
+
+type Hex =
+  | '0'
+  | '1'
+  | '2'
+  | '3'
+  | '4'
+  | '5'
+  | '6'
+  | '7'
+  | '8'
+  | '9'
+  | 'a'
+  | 'b'
+  | 'c'
+  | 'd'
+  | 'e'
+  | 'f'
+
+type Space = ' ' | '\t' | '\n' | '\r' | '\f'
+
+type Boundary =
+  | Space
+  | '('
+  | ')'
+  | '['
+  | ']'
+  | '{'
+  | '}'
+  | ','
+  | '/'
+  | ':'
+  | ';'
+  | '!'
+  | '"'
+  | "'"
+  | '%'
+
+type StripZeros<text extends string> = text extends `0${infer rest}`
+  ? StripZeros<rest>
+  : text
+
+type Code<text extends string> =
+  StripZeros<Lowercase<text>> extends keyof Ascii
+    ? Ascii[StripZeros<Lowercase<text>>]
+    : '�'
+
+type AfterHex<text extends string> = text extends `\r\n${infer rest}`
+  ? rest
+  : text extends `${Space}${infer rest}`
+    ? rest
+    : text
+
+type Escape<
+  text extends string,
+  digits extends string = '',
+  count extends readonly unknown[] = [],
+> = count['length'] extends 6
+  ? readonly [Code<digits>, AfterHex<text>]
+  : text extends `${infer first}${infer rest}`
+    ? Lowercase<first> extends Hex
+      ? Escape<rest, `${digits}${first}`, readonly [...count, 0]>
+      : digits extends ''
+        ? readonly [first extends Ascii[keyof Ascii] ? first : '�', rest]
+        : readonly [Code<digits>, AfterHex<text>]
+    : readonly [Code<digits>, '']
+
+type Prefix<text extends string> = [Numeric.Parse<text>] extends [never]
+  ? ''
+  : Numeric.Parse<text> extends readonly [infer unit extends string, boolean]
+    ? unit extends ''
+      ? text
+      : text extends `${infer prefix}${unit}`
+        ? prefix
+        : ''
+    : ''
+
+// Escapes belong to identifiers, never the numeric part of a dimension token.
+type Token<raw extends string, decoded extends string> =
+  Prefix<raw> extends Prefix<decoded>
+    ? Prefix<decoded> extends Prefix<raw>
+      ? decoded
+      : '�'
+    : '�'
+
+type Scan<
+  text extends string,
+  output extends string = '',
+  raw extends string = '',
+  decoded extends string = '',
+> = text extends `/*${infer _comment}*/${infer rest}`
+  ? Scan<rest, `${output}${Token<raw, decoded>} `>
+  : text extends `\\${infer rest}`
+    ? Escape<rest> extends readonly [
+        infer character extends string,
+        infer tail extends string,
+      ]
+      ? Scan<tail, output, `${raw}\\`, `${decoded}${character}`>
+      : never
+    : text extends `${infer first}${infer rest}`
+      ? first extends Boundary
+        ? Scan<rest, `${output}${Token<raw, decoded>}${first}`>
+        : Scan<rest, output, `${raw}${first}`, `${decoded}${first}`>
+      : `${output}${Token<raw, decoded>}`
+
+/** Leaves ordinary literals untouched; decodes only CSS identifier escapes and comments. */
+export type Normalized<text extends string> =
+  text extends `${string}${'\\' | '/*'}${string}` ? Scan<text> : text
+
+/** CSS keywords use ASCII case folding, including when Unicode has ASCII lowercase mappings. */
+export type Fold<text extends string> =
+  text extends `${infer before}K${infer after}`
+    ? `${Lowercase<before>}K${Fold<after>}`
+    : Lowercase<text>
+
+/** Used only to distinguish literal spellings from theme tokens and importance markers. */
+export function normalize(text: string): string {
+  return text
+    .replace(
+      /\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:[\da-f]{1,6}(?:\r\n|[ \t\n\r\f])?|[^\n\r\f])/gi,
+      (token) => {
+        if (token.startsWith('/*')) return ' '
+
+        const body = token.slice(1)
+        const decoded = /^[\da-f]/i.test(body)
+          ? String.fromCodePoint(Math.min(Number.parseInt(body, 16), 0x10ffff))
+          : body
+
+        return /^[\w-]$/.test(decoded) ? decoded : '�'
+      },
+    )
+    .replace(/[A-Z]/g, (letter) => letter.toLowerCase())
+}