@jesscss/core 2.0.0-alpha.4 → 2.0.0-alpha.6

package/src/tree/condition.ts

@@ -0,0 +1,194 @@
+import type { Class } from 'type-fest';
+import { type Context } from '../context.js';
+import { F_NON_STATIC, F_VISIBLE, Node, defineType, type OptionalLocation, type TreeContext } from './node.js';
+import { Bool } from './bool.js';
+import { type PrintOptions, getPrintOptions } from './util/print.js';
+import { type MaybePromise, pipe, isThenable } from '@jesscss/awaitable-pipe';
+
+/** @note Less will parse =< but it will be stored as <= */
+export type ConditionOperator = 'and' | 'or' | '=' | '>' | '<' | '>=' | '<=';
+
+export type ConditionValue = [
+  left: Node
+] | [
+  left: Node,
+  op: ConditionOperator,
+  right: Node
+];
+
+export type ConditionOptions = {
+  negate?: boolean;
+};
+
+export type ConditionChildData = {
+  left: Node;
+  operator: ConditionOperator | undefined;
+  right: Node | undefined;
+  negate: boolean;
+};
+
+export interface Condition extends Node<ConditionValue, ConditionOptions, ConditionChildData> {
+  type: 'Condition';
+  shortType: 'condition';
+  eval(context: Context): MaybePromise<Bool>;
+}
+
+export class Condition extends Node<ConditionValue, ConditionOptions, ConditionChildData> {
+  static override childKeys = ['left', 'right'] as const;
+
+  readonly left!: Node;
+  private readonly operator: ConditionOperator | undefined;
+  readonly right: Node | undefined;
+  private readonly negate: boolean;
+
+  override clone(deep?: boolean, cloneFn?: (n: Node) => Node, ctx?: Context): this {
+    const left = this.get('left', ctx);
+    const operator = this.get('operator', ctx);
+    const right = this.get('right', ctx);
+    const negate = this.get('negate', ctx);
+    const options = this._meta?.options;
+    const cloneChild = cloneFn ?? ((n: Node) => n.clone(deep, cloneFn, ctx));
+    const value: ConditionValue = operator !== undefined && right !== undefined
+      ? [deep ? cloneChild(left) : left, operator, deep ? cloneChild(right) : right]
+      : [deep ? cloneChild(left) : left];
+    let clonedOptions = options ? { ...options } : undefined;
+    if (negate) {
+      (clonedOptions ??= {}).negate = true;
+    } else if (clonedOptions) {
+      delete clonedOptions.negate;
+    }
+    const newNode = new (this.constructor as Class<this>)(
+      value,
+      clonedOptions,
+      this.location,
+      this.treeContext
+    );
+    newNode.inherit(this);
+    return newNode;
+  }
+
+  constructor(value: ConditionValue, options?: ConditionOptions, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.left = value[0];
+    this.operator = value[1];
+    this.right = value[2];
+    this.negate = !!options?.negate;
+    if (this.left instanceof Node) {
+      this.adopt(this.left);
+    }
+    if (this.right instanceof Node) {
+      this.adopt(this.right);
+    }
+    // Conditions are always non-static, but can inherit may_async from children
+    this.addFlags(F_VISIBLE, F_NON_STATIC);
+  }
+
+  override toTrimmedString(options?: PrintOptions) {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const mark = w.mark();
+    const context = options.context;
+    let left = this.get('left', context);
+    let op = this.get('operator', context);
+    let right = this.get('right', context);
+    const negated = this.get('negate', context);
+    const needsParens = Boolean(right || negated);
+    if (negated) {
+      w.add('not ');
+    }
+    if (needsParens) {
+      w.add('(');
+    }
+    left.toString(options);
+    if (op && right) {
+      w.add(' ');
+      w.add(String(op));
+      w.add(' ');
+      right.toString(options);
+    }
+    if (needsParens) {
+      w.add(')');
+    }
+    return w.getSince(mark);
+  }
+
+  static getBool(node: Node, negated: boolean): Bool {
+    if (node instanceof Bool) {
+      return new Bool(negated ? !node.value : node.value);
+    }
+    // Less guards treat only explicit booleans as truthy.
+    // Any non-boolean (number, quoted, keyword, list, nil, etc.) is false.
+    return new Bool(negated);
+  }
+
+  static getResult(a: Node, b: Node, op: ConditionOperator, context?: Context): boolean {
+    switch (op) {
+      case 'and': return Condition.getBool(a, false).value && Condition.getBool(b, false).value;
+      case 'or': return Condition.getBool(a, false).value || Condition.getBool(b, false).value;
+      default:
+        switch (a.compare(b, context)) {
+          case -1:
+            return op === '<' || op === '<=';
+          case 0:
+            return op === '=' || op === '>=' || op === '<=';
+          case 1:
+            return op === '>' || op === '>=';
+          default:
+            return false;
+        }
+    }
+  }
+
+  override evalNode(context: Context): MaybePromise<Bool> {
+    let left = this.get('left', context);
+    let op = this.get('operator', context);
+    let right = this.get('right', context);
+    let negated = this.get('negate', context);
+
+    return pipe(
+      () => left.eval(context),
+      (a) => {
+        if (!right) {
+          // Defer unary coercion to the final stage to avoid double-negation.
+          return a;
+        }
+        return a;
+      },
+      (a) => {
+        if (!right) {
+          return [a];
+        }
+        let b = right.eval(context);
+        if (isThenable(b)) {
+          return (b as Promise<Node>).then(bb => [a, bb] as const);
+        }
+        return [a, b];
+      },
+      ([a, b]) => {
+        if (!b) {
+          const unary = Condition.getBool(a, negated);
+          return unary;
+        }
+        const normalizeDefaultCall = (node: Node): Node => {
+          if (node.type !== 'Call') {
+            return node;
+          }
+          const rawCallName = (node as import('./call.js').Call).name;
+          const callName = String(typeof rawCallName === 'string'
+            ? rawCallName
+            : rawCallName?.valueOf?.() ?? '');
+          if (callName === 'default' || callName === '??') {
+            return new Bool(Boolean(context.isDefault));
+          }
+          return node;
+        };
+        a = normalizeDefaultCall(a);
+        b = normalizeDefaultCall(b);
+        let result = Condition.getResult(a, b, op!, context);
+        return new Bool(negated ? !result : result);
+      }
+    );
+  }
+}
+
+export const condition = defineType(Condition, 'Condition');

package/src/tree/control.ts

@@ -0,0 +1,452 @@
+import { Node, defineType, F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC, type OptionalLocation } from './node.js';
+import type { Context, TreeContext } from '../context.js';
+import { Rules } from './rules.js';
+import { Sequence } from './sequence.js';
+import { Any } from './any.js';
+import { Num } from './number.js';
+import { VarDeclaration } from './declaration-var.js';
+import { isNode } from './util/is-node.js';
+import { N } from './node-type.js';
+import { type PrintOptions, getPrintOptions } from './util/print.js';
+import type { MaybePromise } from '@jesscss/awaitable-pipe';
+import { List } from './list.js';
+import type { Mixin } from './mixin.js';
+import { appendScopedOutputNodes, createCounterNode, evaluateScopedBodyWithBindings } from './util/scoped-body-eval.js';
+
+const PUBLIC_RULE_VISIBILITY = {
+  Declaration: 'public',
+  Ruleset: 'public',
+  VarDeclaration: 'public',
+  Mixin: 'public'
+} as const;
+
+function makeDirectiveRulesPublic(rules: Rules) {
+  rules.options.rulesVisibility = {
+    ...rules.options.rulesVisibility,
+    ...PUBLIC_RULE_VISIBILITY
+  };
+}
+
+type LegacyLoopValue = {
+  header: Sequence;
+  rules: Rules;
+};
+
+export type ForValue = {
+  vars: VarDeclaration | VarDeclaration[];
+  iterable: Node;
+  rules: Rules;
+};
+
+function getBindingNames(vars: VarDeclaration | VarDeclaration[]): string[] {
+  if (Array.isArray(vars)) {
+    return vars.map(v => v.get('name').valueOf());
+  }
+  return [vars.get('name').valueOf()];
+}
+
+function varsToNode(vars: VarDeclaration | VarDeclaration[]): Node {
+  if (!Array.isArray(vars)) {
+    return vars;
+  }
+  const wrapper = new List<VarDeclaration>([], { sep: ',' });
+  wrapper.value = [...vars];
+  return wrapper;
+}
+
+async function resolveLoopEntryKey(
+  key: number | string | Node,
+  counter: number,
+  context: Context
+): Promise<Node> {
+  if (typeof key === 'number') {
+    return new Num(key + 1);
+  }
+  if (typeof key === 'string' && key === 'value') {
+    return new Num(counter);
+  }
+  if (isNode(key)) {
+    return await key.eval(context);
+  }
+  return new Any(String(key), { role: 'property' });
+}
+
+async function evaluateForIteration(
+  loopTemplate: Rules,
+  accumulatedNodes: readonly Node[],
+  bindingNames: readonly string[],
+  value: Node,
+  key: number | string | Node,
+  counter: number,
+  context: Context
+): Promise<Node[]> {
+  const resolvedValue = await value.eval(context);
+  const resolvedKey = await resolveLoopEntryKey(key, counter, context);
+  return evaluateScopedBodyWithBindings(
+    loopTemplate,
+    accumulatedNodes,
+    [
+      { name: bindingNames[0]!, value: resolvedValue },
+      { name: bindingNames[1] ?? '', value: resolvedKey },
+      { name: bindingNames[2] ?? '', value: createCounterNode(counter) }
+    ].filter(binding => binding.name),
+    context
+  );
+}
+
+async function evaluateForOutput(
+  loopTemplate: Rules,
+  bindingNames: readonly string[],
+  evaluatedIterable: Node,
+  context: Context
+): Promise<Rules> {
+  const accumulatedNodes: Node[] = [];
+  let counter = 1;
+  for await (const [value, key] of resolveEntries(evaluatedIterable, context)) {
+    const outputNodes = await evaluateForIteration(
+      loopTemplate,
+      accumulatedNodes,
+      bindingNames,
+      value,
+      key,
+      counter,
+      context
+    );
+    counter++;
+    appendScopedOutputNodes(accumulatedNodes, outputNodes, context);
+  }
+  return new Rules(accumulatedNodes);
+}
+
+async function* resolveEntries(input: Node, context: Context): AsyncGenerator<[Node, number | string | Node]> {
+  if (isNode(input, N.Expression)) {
+    yield* resolveEntries(await input.get('value', context).eval(context), context);
+    return;
+  }
+  if (isNode(input, N.Call)) {
+    const evald = await input.eval(context);
+    if (isNode(evald, N.Call)) {
+      yield [evald, 0];
+      return;
+    }
+    yield* resolveEntries(evald, context);
+    return;
+  }
+  if (isNode(input, N.Paren)) {
+    const parenValue = input.get('value', context);
+    if (parenValue instanceof Node) {
+      yield* resolveEntries(parenValue, context);
+      return;
+    }
+  }
+  if ((isNode(input, N.Sequence) || isNode(input, N.List))) {
+    const items = input.get('value', context);
+    if (Array.isArray(items)) {
+      for (let key = 0; key < items.length; key++) {
+        const value = items[key]!;
+        yield [value, key];
+      }
+      return;
+    }
+  }
+  if (isNode(input, N.Rules | N.Ruleset | N.Mixin)) {
+    const rules: readonly Node[] = isNode(input, N.Rules)
+      ? input.value
+      : isNode(input, N.Ruleset)
+        ? (input.getRules(context?.renderKey ?? input.renderKey)?.value ?? [])
+        : (((input as Mixin).get('rules')?.value) ?? []);
+    for (const rule of rules) {
+      if (!rule || isNode(rule, N.Comment)) {
+        continue;
+      }
+      if (!isNode(rule, N.Declaration)) {
+        continue;
+      }
+      yield [
+        (rule as Node & { value: Node }).value,
+        (rule as Node & { name: Node }).name
+      ];
+    }
+    return;
+  }
+  yield [input, 0];
+}
+
+/** @todo - I don't understand how these are different or why the LLM did this? */
+export type IfValue = {
+  conditions: Node[];
+  bodies: Rules[];
+  elseBranch?: Rules;
+};
+
+export type IfChildData = {
+  conditions: Node[];
+  bodies: Rules[];
+  elseBranch: Rules | undefined;
+};
+
+/**
+ * A control-flow block that serializes as:
+ * - `$if (...) { ... }`
+ * - `$else if (...) { ... }`
+ * - `$else { ... }`
+ *
+ * This is language-agnostic: it's the canonical Jess control node.
+ */
+export interface If extends Node<IfValue, any, IfChildData> {
+  type: 'If';
+  shortType: 'if';
+}
+export class If extends Node<IfValue, any, IfChildData> {
+  static override childKeys = ['conditions', 'bodies', 'elseBranch'] as const;
+
+  readonly conditions!: Node[];
+  readonly bodies!: Rules[];
+  readonly elseBranch: Rules | undefined;
+
+  constructor(value: IfValue, options?: any, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.conditions = value.conditions;
+    this.bodies = value.bodies;
+    this.elseBranch = value.elseBranch;
+    for (const cond of this.conditions) {
+      if (cond instanceof Node) {
+        this.adopt(cond);
+      }
+    }
+    for (const body of this.bodies) {
+      if (body instanceof Node) {
+        this.adopt(body);
+      }
+      makeDirectiveRulesPublic(body);
+    }
+    if (this.elseBranch) {
+      if (this.elseBranch instanceof Node) {
+        this.adopt(this.elseBranch);
+      }
+      makeDirectiveRulesPublic(this.elseBranch);
+    }
+    this.allowRoot = true;
+    this.allowRuleRoot = true;
+    this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+  }
+
+  override toTrimmedString(options?: PrintOptions): string {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const mark = w.mark();
+    const context = options.context;
+
+    const conditions = this.get('conditions', context);
+    const bodies = this.get('bodies', context);
+    const elseBranch = this.get('elseBranch', context);
+    w.add('$if', this);
+    w.add(' (');
+    conditions[0]?.toString(options);
+    w.add(') ');
+    bodies[0]?.toBraced(options);
+
+    for (let i = 1; i < conditions.length; i++) {
+      w.add(' $else if (');
+      conditions[i]!.toString(options);
+      w.add(') ');
+      bodies[i]?.toBraced(options);
+    }
+
+    if (elseBranch) {
+      w.add(' $else ');
+      elseBranch.toBraced(options);
+    }
+
+    return w.getSince(mark);
+  }
+}
+
+export type ForChildData = {
+  vars: VarDeclaration | VarDeclaration[];
+  iterable: Node;
+  rules: Rules;
+};
+
+export interface For extends Node<ForValue, any, ForChildData> {
+  type: 'For';
+  shortType: 'for';
+}
+/**
+ * `$for <header> { ... }`
+ */
+export class For extends Node<ForValue, any, ForChildData> {
+  static override childKeys = ['vars', 'iterable', 'rules'] as const;
+
+  readonly vars!: VarDeclaration | VarDeclaration[];
+  readonly iterable!: Node;
+  readonly rules!: Rules;
+
+  constructor(value: ForValue, options?: any, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.vars = value.vars;
+    this.iterable = value.iterable;
+    this.rules = value.rules;
+    if (Array.isArray(this.vars)) {
+      for (const v of this.vars) {
+        if (v instanceof Node) {
+          this.adopt(v);
+        }
+      }
+    } else if (this.vars instanceof Node) {
+      this.adopt(this.vars);
+    }
+    if (this.iterable instanceof Node) {
+      this.adopt(this.iterable);
+    }
+    if (this.rules instanceof Node) {
+      this.adopt(this.rules);
+    }
+    this.allowRoot = true;
+    this.allowRuleRoot = true;
+    this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+    makeDirectiveRulesPublic(this.rules);
+  }
+
+  override preEval(context: Context): MaybePromise<Node> {
+    if (!this.preEvaluated) {
+      this.preEvaluated = true;
+      return this;
+    }
+    return this;
+  }
+
+  override evalNode(context: Context): MaybePromise<Node> {
+    const vars = this.get('vars', context);
+    const iterable = this.get('iterable', context);
+    const loopTemplate = this.get('rules', context).withRenderOwner(this, context.renderKey, context);
+    const bindingNames = getBindingNames(vars);
+    if (bindingNames.length === 0) {
+      throw new Error('Invalid $for header: missing binding variable');
+    }
+    const run = async (): Promise<Node> => {
+      const evaluatedIterable = await iterable.eval(context);
+      return evaluateForOutput(loopTemplate, bindingNames, evaluatedIterable, context);
+    };
+    return run();
+  }
+
+  override toTrimmedString(options?: PrintOptions): string {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const mark = w.mark();
+    const context = options.context;
+    w.add('$for ', this);
+    w.add('(');
+    varsToNode(this.get('vars', context)).toString(options);
+    w.add(' of ');
+    this.get('iterable', context).toString(options);
+    w.add(')');
+    w.add(' ');
+    this.get('rules', context).withRenderOwner(this, context?.renderKey, context).toBraced(options);
+    return w.getSince(mark);
+  }
+}
+
+/**
+ * `$each <header> { ... }`
+ */
+export type EachChildData = {
+  header: Sequence;
+  rules: Rules;
+};
+
+export interface Each extends Node<LegacyLoopValue, any, EachChildData> {
+  type: 'Each';
+  shortType: 'each';
+}
+export class Each extends Node<LegacyLoopValue, any, EachChildData> {
+  static override childKeys = ['header', 'rules'] as const;
+
+  readonly header!: Sequence;
+  readonly rules!: Rules;
+
+  constructor(value: LegacyLoopValue, options?: any, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.header = value.header;
+    this.rules = value.rules;
+    if (this.header instanceof Node) {
+      this.adopt(this.header);
+    }
+    if (this.rules instanceof Node) {
+      this.adopt(this.rules);
+    }
+    this.allowRoot = true;
+    this.allowRuleRoot = true;
+    this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+  }
+
+  override toTrimmedString(options?: PrintOptions): string {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const mark = w.mark();
+    const context = options.context;
+    w.add('$each ', this);
+    this.get('header', context).toString(options);
+    w.add(' ');
+    this.get('rules', context).withRenderOwner(this, context?.renderKey, context).toBraced(options);
+    return w.getSince(mark);
+  }
+}
+
+export type WhileValue = {
+  condition: Node;
+  rules: Rules;
+};
+
+export type WhileChildData = {
+  condition: Node;
+  rules: Rules;
+};
+
+/**
+ * `$while (<condition>) { ... }`
+ */
+export interface While extends Node<WhileValue, any, WhileChildData> {
+  type: 'While';
+  shortType: 'while';
+}
+export class While extends Node<WhileValue, any, WhileChildData> {
+  static override childKeys = ['condition', 'rules'] as const;
+
+  readonly condition!: Node;
+  readonly rules!: Rules;
+
+  constructor(value: WhileValue, options?: any, location?: OptionalLocation, treeContext?: TreeContext) {
+    super(value, options, location, treeContext);
+    this.condition = value.condition;
+    this.rules = value.rules;
+    if (this.condition instanceof Node) {
+      this.adopt(this.condition);
+    }
+    if (this.rules instanceof Node) {
+      this.adopt(this.rules);
+    }
+    this.allowRoot = true;
+    this.allowRuleRoot = true;
+    this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+    makeDirectiveRulesPublic(this.rules);
+  }
+
+  override toTrimmedString(options?: PrintOptions): string {
+    options = getPrintOptions(options);
+    const w = options.writer!;
+    const mark = w.mark();
+    const context = options.context;
+    w.add('$while (', this);
+    this.get('condition', context).toString(options);
+    w.add(') ');
+    this.get('rules', context).withRenderOwner(this, context?.renderKey, context).toBraced(options);
+    return w.getSince(mark);
+  }
+}
+
+export const ifNode = defineType(If, 'If', 'if');
+export const forNode = defineType(For, 'For', 'for');
+export const eachNode = defineType(Each, 'Each', 'each');
+export const whileNode = defineType(While, 'While', 'while');

package/src/tree/declaration-custom.ts

@@ -0,0 +1,56 @@
+import { Declaration } from './declaration.js';
+import { defineType } from './node.js';
+import type { Context } from '../context.js';
+import type { Nil } from './nil.js';
+import { type MaybePromise, pipe } from '@jesscss/awaitable-pipe';
+// import type { OutputCollector } from '../output'
+
+/**
+ * A declaration that retains all tokens
+ * (white-space, comments, etc)
+ *
+ * Ideally, perhaps, the value would just be
+ * one Anonymous node for now?
+ *
+ * @todo - is this used?
+ */
+export class CustomDeclaration extends Declaration {
+  override evalNode(context: Context): MaybePromise<this | Nil> {
+    context.inCustom = true;
+    return pipe(
+      () => super.evalNode(context),
+      (node) => {
+        context.inCustom = false;
+        return node as this | Nil;
+      }
+    );
+  }
+
+  /** @todo move to visitors */
+  // toCSS(context: Context, out: OutputCollector) {
+  //   const loc = this.location
+  //   this.name.toCSS(context, out)
+  //   /**
+  //    * Don't insert a space after the colon;
+  //    * Instead, insert the exact token stream.
+  //    *
+  //    * @todo - test this
+  //    */
+  //   out.add(':', loc)
+  //   this.data.toCSS(context, out)
+  //   out.add(';', loc)
+  // }
+
+  // toModule(context: Context, out: OutputCollector) {
+  //   const pre = context.pre
+  //   const loc = this.location
+  //   out.add('$J.custom({\n', loc)
+  //   out.add(`  ${pre}name: `)
+  //   this.name.toModule(context, out)
+  //   out.add(`\n  ${pre}value: `)
+  //   this.data.toModule(context, out)
+  //   out.add(`\n${pre}})`)
+  // }
+}
+
+export const customdecl = defineType(CustomDeclaration, 'CustomDeclaration', 'custom');