npm - sandstone - Versions diffs - 1.1.6 → 1.2.1 - Mend

sandstone 1.1.6 → 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (443) hide show

package/src/pack/visitors/orTransformationVisitor.ts CHANGED Viewed

@@ -1,342 +1,68 @@
-import { ExecuteCommandNode, type SubCommand, ReturnCommandNode, ScoreboardCommandNode } from '../../commands'
-import { MCFunctionClass, type MCFunctionNode, type Node, type SandstoneCore } from '../../core'
-import type { Score } from '../../variables'
-import { AndNode, ConditionNode, IfNode, NotNode, OrNode } from '../../flow'
+import { ScoreboardCommandNode } from '../../commands'
+import type { Node } from '../../core'
+import { AndNode, type ConditionNode, IfNode, NotNode, OrNode } from '../../flow'
 import { GenericSandstoneVisitor } from './visitor'
-/**
- * Condition node whose `getValue()` returns `"if function <name>"`.
- * Used to make an IfNode's existing `IfElseTransformationVisitor` emit
- * `execute if function <child> run <body>`, which succeeds exactly when the
- * child MCFunction returns a positive value (e.g. via an early `return 1`).
- */
-class FunctionReturnConditionNode extends ConditionNode {
-  constructor(
-    public sandstoneCore: SandstoneCore,
-    public functionName: string,
-  ) {
-    super(sandstoneCore)
-  }
-  getValue = () => `if function ${this.functionName}`
-}
 export class OrTransformationVisitor extends GenericSandstoneVisitor {
   visitIfNode = (node_: IfNode) => {
-    const { preNodes, conditionNode } = this.parseConditionNode(node_.condition, node_.parentMCFunction)
+    const { preNodes, conditionNode } = this.parseConditionNode(node_.condition)
     node_.condition = conditionNode
     return [...preNodes, this.genericVisit(node_)]
   }
-  parseConditionNode = (node: ConditionNode, parentMCFunction?: MCFunctionNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
+  parseConditionNode = (node: ConditionNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
     if (node instanceof OrNode) {
-      return this.parseOrNode(node, parentMCFunction)
+      return this.parseOrNode(node)
     }
     if (node instanceof AndNode) {
-      return this.parseAndNode(node, parentMCFunction)
+      return this.parseAndNode(node)
     }
     if (node instanceof NotNode) {
-      return this.parseNotNode(node, parentMCFunction)
+      return this.parseNotNode(node)
     }
-    // `preNodes` is optional on ConditionNode. Side-effecting conditions (those that
-    // commit commands at construction, e.g. `data.equals`, `Label.equals`, any
-    // `CommandCondition`) populate it; pure predicates leave it unset.
-    return { preNodes: [...(node.preNodes ?? [])], conditionNode: node }
+    // Default case, just return the node as is
+    return { preNodes: [], conditionNode: node }
   }
+  parseOrNode = (node: OrNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
+    const variable = this.core.pack.Variable(undefined, 'condition')
-  parseOrNode = (node: OrNode, parentMCFunction?: MCFunctionNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
-    // Single branch: collapse through so the IfNode behaves as if it had the inner condition.
-    if (node.conditions.length === 1) {
-      return this.parseConditionNode(node.conditions[0], parentMCFunction)
-    }
-    // Multiple branches: extract to a child MCFunction with execute-if-return-1 short-circuit.
-    // Inside the child: `execute if <c1> run return 1`, `execute if <c2> run return 1`, ..., `return 0`.
-    // The first matching branch returns 1 and exits the function immediately; the rest are skipped.
-    // The caller uses `execute if function <child>` to test whether any branch matched.
-    const parentName = parentMCFunction?.resource.name ?? '__sandstone'
-    const orMCFunction = new MCFunctionClass(
-      this.core,
-      `${parentName}/or_check`,
-      {
-        addToSandstoneCore: true,
-        creator: 'sandstone',
-        onConflict: 'rename',
-      },
-    )
-    this.core.enterMCFunction(orMCFunction)
+    const conditionNode = variable.equalTo(1)._toMinecraftCondition()
-    try {
-      for (const condition of node.conditions) {
-        this.pushCheckBranch(orMCFunction.node, this.parseConditionNode(condition, orMCFunction.node), false, new ReturnCommandNode(this.pack, [1]))
-      }
+    const realPreNodes: Node[] = [new ScoreboardCommandNode(this.pack, 'players', 'reset', variable)]
+    const orExecuteNodes = node.conditions.map((condition) => {
+      const { preNodes, conditionNode: parsedConditionNode } = this.parseConditionNode(condition)
+      realPreNodes.push(...preNodes)
-      // Default return: no branch matched.
-      orMCFunction.node.body.push(new ReturnCommandNode(this.pack, [0]))
-    } finally {
-      this.core.exitMCFunction()
-    }
+      const ifNode = new IfNode(this.core, parsedConditionNode)
+      ifNode.body = [new ScoreboardCommandNode(this.pack, 'players', 'set', variable, 1)]
+      return ifNode
+    })
     return {
-      preNodes: [],
-      conditionNode: new FunctionReturnConditionNode(this.core, orMCFunction.name),
+      preNodes: [...realPreNodes, ...orExecuteNodes],
+      conditionNode,
     }
   }
-  parseAndNode = (node: AndNode, parentMCFunction?: MCFunctionNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
-    // Single branch: collapse through so the IfNode behaves as if it had the inner condition.
-    if (node.conditions.length === 1) {
-      return this.parseConditionNode(node.conditions[0], parentMCFunction)
-    }
-    // Parse every condition to learn whether it carries commands (preNodes) that must run
-    // before the predicate is evaluated. Pure-predicate conditions chain cleanly inside a
-    // single execute — those are batched. Command-needing conditions force the AND into a
-    // child MCFunction so commands can run inline before their check.
-    const parsed = node.conditions.map((condition) => this.parseConditionNode(condition, parentMCFunction))
-    const anyHasCommands = parsed.some((p) => (p.preNodes ?? []).length > 0)
-    if (!anyHasCommands) {
-      // Inline: pure conditions chain via the existing AndNode behavior. Order is preserved
-      // by `Array.prototype.map`. No child function needed.
-      const finalPreNodes: Node[] = []
-      const conditionNode = new AndNode(
-        node.sandstoneCore,
-        parsed.map((p) => {
-          finalPreNodes.push(...p.preNodes)
-          return p.conditionNode
-        }),
-      )
-      return { preNodes: finalPreNodes, conditionNode }
-    }
-    // At least one condition needs to run commands. Extract to a child MCFunction:
-    //   - Pure-predicate runs are batched into `execute <pos-c1> <pos-c2> ... run return 1`
-    //     (positive form, NOT flipped — chain fires `return 1` only when the whole batch
-    //     holds; otherwise we fall through to the next check).
-    //   - Command-needing conditions emit their stashed side-effects inline, then a flipped
-    //     `execute if <failure-form> run return 0` so the function returns 0 as soon as a
-    //     side-effecting check fails to hold.
-    //   - Default `return 0` reaches the end only when no command-needing check failed and
-    //     no pure batch all-held; the function returns 1 only via a pure-batch success path,
-    //     signalled to the caller by `execute if function <and>`.
-    const parentName = parentMCFunction?.resource.name ?? '__sandstone'
-    const andMCFunction = new MCFunctionClass(
-      this.core,
-      `${parentName}/and_check`,
-      {
-        addToSandstoneCore: true,
-        creator: 'sandstone',
-        onConflict: 'rename',
-      },
+  parseAndNode = (node: AndNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
+    const finalPreNodes: Node[] = []
+    const conditionNode = new AndNode(
+      node.sandstoneCore,
+      node.conditions.map((condition) => {
+        const { preNodes, conditionNode } = this.parseConditionNode(condition)
+        finalPreNodes.push(...preNodes)
+        return conditionNode
+      }),
     )
-    this.core.enterMCFunction(andMCFunction)
-    try {
-      let batch: { preNodes: Node[][]; conditionNodes: ConditionNode[] } = { preNodes: [], conditionNodes: [] }
-      const flushBatch = () => {
-        if (batch.conditionNodes.length === 0 && batch.preNodes.every((pn) => pn.length === 0)) {
-          batch = { preNodes: [], conditionNodes: [] }
-          return
-        }
-        // Per-batch tracker-var pattern: reset the tracker, run the chained execute to set
-        // the tracker to 1 only when the entire batch holds, then check the tracker and
-        // `return 0` if any condition failed (var != 1). Each batch uses its own tracker var
-        // so concurrent/sequential batches stay independent.
-        const tracker = this.core.pack.Variable(undefined, 'and_batch')
-        this.pushBatchedCheckBranch(
-          andMCFunction.node,
-          batch.preNodes.flat(),
-          batch.conditionNodes,
-          tracker,
-        )
-        batch = { preNodes: [], conditionNodes: [] }
-      }
-      for (const p of parsed) {
-        if (p.preNodes.length === 0) {
-          // Pure predicate: extend the current batch (still in declared order).
-          batch.preNodes.push(p.preNodes)
-          batch.conditionNodes.push(p.conditionNode)
-        } else {
-          // Command-needing condition: flush any pending batch first (preserving order),
-          // then emit this condition's commands followed by its own fail-fast check.
-          flushBatch()
-          this.pushFailFastBranch(
-            andMCFunction.node,
-            p,
-            new ReturnCommandNode(this.pack, [0]),
-          )
-        }
-      }
-      flushBatch()
-      // Default return: every check ran without success.
-      andMCFunction.node.body.push(new ReturnCommandNode(this.pack, [1]))
-    } finally {
-      this.core.exitMCFunction()
-    }
     return {
-      preNodes: [],
-      conditionNode: new FunctionReturnConditionNode(this.core, andMCFunction.name),
+      preNodes: finalPreNodes,
+      conditionNode,
     }
   }
-  /**
-   * Pushes a batched check into `targetMCFunction.body` using the tracker-var pattern:
-   *   <preNodes...>
-   *   scoreboard players reset <tracker>
-   *   execute <if|unless> <c1> <if|unless> <c2> ... run scoreboard players set <tracker> 1
-   *   execute unless score <tracker> matches 1 run return 0
-   *
-   * Consecutive pure-predicate conditions from the AND list coalesce into a single chained
-   * execute that sets the tracker to 1 only when the entire batch holds. The trailing
-   * fail-check returns 0 from the child MCFunction when any condition failed (var != 1).
-   * Using a tracker var avoids the "execute-chain only fires on ALL-pass" limitation of
-   * pure MC chains while keeping the body tight.
-   */
-  private pushBatchedCheckBranch = (
-    targetMCFunction: MCFunctionNode,
-    preNodes: Node[],
-    conditionNodes: ConditionNode[],
-    tracker: Score,
-  ) => {
-    for (const n of preNodes) {
-      targetMCFunction.body.push(n)
-    }
-    targetMCFunction.body.push(new ScoreboardCommandNode(this.pack, 'players', 'reset', tracker))
-    const args: SubCommand[] = []
-    for (const c of conditionNodes) {
-      const condStr = c.getValue(false)
-      const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/)
-      if (!match) {
-        throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`)
-      }
-      const [, keyword, condBody] = match
-      args.push([keyword, condBody])
-    }
-    if (args.length === 0) {
-      // No conditions but preNodes ran — push an unconditional set so the trailing check
-      // doesn't fire on a stale tracker.
-      targetMCFunction.body.push(new ScoreboardCommandNode(this.pack, 'players', 'set', tracker, 1))
-    } else {
-      const executeNode = new ExecuteCommandNode(this.pack, args, {
-        isSingleExecute: true,
-        body: [],
-      })
-      targetMCFunction.enterContext(executeNode, false)
-      executeNode.body = [new ScoreboardCommandNode(this.pack, 'players', 'set', tracker, 1)]
-      targetMCFunction.body.push(executeNode)
-      targetMCFunction.exitContext()
-    }
-    const failCheckNode = new ExecuteCommandNode(
-      this.pack,
-      [['unless', `score ${tracker} matches 1`]],
-      {
-        isSingleExecute: true,
-        body: [],
-      },
-    )
-    targetMCFunction.enterContext(failCheckNode, false)
-    failCheckNode.body = [new ReturnCommandNode(this.pack, [0])]
-    targetMCFunction.body.push(failCheckNode)
-    targetMCFunction.exitContext()
-  }
-  /**
-   * Pushes a single check branch into `targetMCFunction.body`:
-   *   <preNodes...> (side-effect commands that must run before checking)
-   *   execute <if|unless> <condBody> run <bodyNode>
-   *
-   * When `negated` is false, the helper uses the condition's positive form
-   * (`getValue(false)`); when true, it uses the failure form (`getValue(true)`).
-   * For OR semantics: pass `negated=false` with `bodyNode = return 1` (exit on first match).
-   */
-  private pushCheckBranch = (
-    targetMCFunction: MCFunctionNode,
-    parsed: { preNodes: Node[]; conditionNode: ConditionNode },
-    negated: boolean,
-    bodyNode: Node,
-  ) => {
-    // Any nested preNodes (e.g. nested or/and reset+score commands, or the inner
-    // condition's side-effect commands) run inside the child function body in order.
-    for (const n of parsed.preNodes) {
-      targetMCFunction.body.push(n)
-    }
-    // Extract the chain keyword ("if" or "unless") and the condition body from `getValue()`.
-    // SingleConditionNode returns "if <body>"; NotNode-wrapped conditions return "unless <body>".
-    // AndNode already produces execute-chain strings; a nested FunctionReturnConditionNode
-    // returns "if function <name>" which fits the same shape.
-    const condStr = parsed.conditionNode.getValue(negated)
-    const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/)
-    if (!match) {
-      throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`)
-    }
-    const [, keyword, condBody] = match
-    // Construct ExecuteCommandNode for `execute <keyword> <condBody> run <bodyNode>`.
-    // The constructor's append() calls exitContext, so we first push an empty executeNode
-    // into the MCFunction context stack (addNode=false) so the exit succeeds.
-    const executeNode = new ExecuteCommandNode(this.pack, [[keyword, condBody]], {
-      isSingleExecute: true,
-      body: [],
-    })
-    targetMCFunction.enterContext(executeNode, false)
-    executeNode.body = [bodyNode]
-    targetMCFunction.body.push(executeNode)
-    targetMCFunction.exitContext()
-  }
-  /**
-   * Pushes a fail-fast check for an AND command-needing condition into `targetMCFunction.body`:
-   *   <preNodes...>
-   *   execute <if|unless> <condBody> run <bodyNode>
-   *
-   * Uses the condition's FAILURE form (`getValue(true)`) and flips the leading
-   * `if`/`unless` keyword so the execute fires when the condition fails to hold. The
-   * `bodyNode` (typically `return 0`) exits the child MCFunction immediately. When the
-   * condition holds, the chain doesn't fire and we fall through to the next check.
-   */
-  private pushFailFastBranch = (
-    targetMCFunction: MCFunctionNode,
-    parsed: { preNodes: Node[]; conditionNode: ConditionNode },
-    bodyNode: Node,
-  ) => {
-    for (const n of parsed.preNodes) {
-      targetMCFunction.body.push(n)
-    }
-    const condStr = parsed.conditionNode.getValue(true)
-    const match = condStr.match(/^(if|unless)\s+([\s\S]+)$/)
-    if (!match) {
-      throw new Error(`OrTransformationVisitor: unexpected condition getValue() shape: ${condStr}`)
-    }
-    // Flip the leading keyword so the execute fires on failure rather than success.
-    const flippedKeyword = match[1] === 'if' ? 'unless' : 'if'
-    const condBody = match[2]
-    const executeNode = new ExecuteCommandNode(this.pack, [[flippedKeyword, condBody]], {
-      isSingleExecute: true,
-      body: [],
-    })
-    targetMCFunction.enterContext(executeNode, false)
-    executeNode.body = [bodyNode]
-    targetMCFunction.body.push(executeNode)
-    targetMCFunction.exitContext()
-  }
-  parseNotNode = (node: NotNode, parentMCFunction?: MCFunctionNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
-    const { preNodes, conditionNode } = this.parseConditionNode(node.condition, parentMCFunction)
+  parseNotNode = (node: NotNode): { preNodes: Node[]; conditionNode: ConditionNode } => {
+    const { preNodes, conditionNode } = this.parseConditionNode(node.condition)
     return {
       preNodes,
       conditionNode: new NotNode(node.sandstoneCore, conditionNode),

package/src/sandstone.ts CHANGED Viewed

@@ -8,6 +8,7 @@ import type {
   BlockStateDefinitionArguments,
   ChatTypeClassArguments,
   DamageTypeClassArguments,
+  DecoratedPotPatternClassArguments,
   DialogClassArguments,
   EnchantmentClassArguments,
   EnchantmentProviderClassArguments,
@@ -27,6 +28,7 @@ import type {
   PredicateClassArguments,
   RecipeClassArguments,
   ShaderClassArguments,
+  SlotSourceClassArguments,
   SoundEventArguments,
   SoundsIndexArguments,
   SulfurCubeArchetypeClassArguments,
@@ -236,7 +238,7 @@ type PackNonMethodKeys =
   | 'conditions' | 'objectives' | 'anonymousScoreId' | 'anonymousDataId' | 'constants' | 'tickedLoops'
   | '__rootObjective' | 'packUid'
   | 'reset' | 'appendNode' | 'initMCFunction' | 'save' | 'resourceToPath' | 'rootObjective'
-  | 'setupLantern' | 'dataPack' | 'resourcePack' | 'registerTickedCommands'
+  | 'setupLantern' | 'dataPack' | 'resourcePack' | 'registerTickedCommands' | 'Variant'
 type PackMethodKeys = Exclude<keyof SandstonePack, PackNonMethodKeys>
 // Creates a proxy that handles both callable methods and object-based properties.
@@ -293,6 +295,7 @@ export const {
   BannerPattern,
   ChatType,
   DamageType,
+  DecoratedPotPattern,
   Dialog,
   Enchantment,
   EnchantmentProvider,
@@ -302,6 +305,7 @@ export const {
   LootTable,
   Predicate,
   Recipe,
+  SlotSource,
   SulfurCubeArchetype,
   Tag,
   TestEnvironment,
@@ -311,7 +315,6 @@ export const {
   TrialSpawner,
   TrimMaterial,
   TrimPattern,
-  Variant,
   VillagerTrade,
   WorldClock,
@@ -354,7 +357,40 @@ export const {
   defaultNamespace,
 } = packMethodsProxy
-export * from './variables/nbt/NBTs'
+// Variant needs explicit type annotation due to complex generics
+export const Variant: typeof sandstonePack.Variant = ((...args: unknown[]) =>
+  (sandstonePack.Variant as CallableFunction)(...args)) as typeof sandstonePack.Variant
+// Explicit re-export (not `export *`) so the library builder can hoist
+// these as top-level imports in the bundled main. Wildcard re-exports
+// make it impossible for the bundler to know which names need to be
+// imported into the bundled main's scope.
+export {
+  NBTAnyValue,
+  NBTByte,
+  NBTByteArray,
+  NBTClass,
+  NBTDouble,
+  NBTFloat,
+  NBTInt,
+  NBTIntArray,
+  NBTList,
+  NBTLong,
+  NBTLongArray,
+  NBTPrimitive,
+  NBTRange,
+  NBTShort,
+  NBTString,
+  NBTTypedArray,
+  NotNBT,
+  ResolvedNBT,
+  type NBTAllArrays,
+  type NBTAllNumberClasses,
+  type NBTAllNumbers,
+  type NBTAllPrimitives,
+  type NBTAllValues,
+  type NBTSimpleClasses,
+} from './variables/nbt/NBTs'
 export type { Condition } from './flow'
 export {
@@ -376,6 +412,7 @@ export {
   BannerPatternClass,
   ChatTypeClass,
   DamageTypeClass,
+  DecoratedPotPatternClass,
   DialogClass,
   EnchantmentClass,
   EnchantmentProviderClass,
@@ -385,6 +422,7 @@ export {
   LootTableClass,
   PredicateClass,
   RecipeClass,
+  SlotSourceClass,
   StructureClass,
   SulfurCubeArchetypeClass,
   TagClass,
@@ -667,6 +705,11 @@ type ContentStrategy =
    * Will override the defined `default` strategy.
    */
   | ContentStrategyKind<'recipe', NonNullable<RecipeClassArguments['onConflict']>>
+  /**
+   * The conflict strategy to use for Slot sources.
+   * Will override the defined `default` strategy.
+   */
+   | ContentStrategyKind<'slot_source', NonNullable<SlotSourceClassArguments['onConflict']>>
   /**
    * The conflict strategy to use for Sulfur cube archetypes.
    * Will override the defined `default` strategy.
@@ -702,6 +745,11 @@ type ContentStrategy =
    * Will override the defined `default` strategy.
    */
   | ContentStrategyKind<'chat_type', NonNullable<ChatTypeClassArguments['onConflict']>>
+  /**
+   * The conflict strategy to use for Decorated pot patterns.
+   * Will override the defined `default` strategy.
+   */
+   | ContentStrategyKind<'decorated_pot_pattern', NonNullable<DecoratedPotPatternClassArguments['onConflict']>>
   /**
    * The conflict strategy to use for Dialogs.
    * Will override the defined `default` strategy.
@@ -828,6 +876,11 @@ type ContentStrategy =
    * Will override the defined `default` strategy.
    */
   | ContentStrategyKind<'shader', NonNullable<ShaderClassArguments['onConflict']>>
+  /**
+   * The conflict strategy to use for SoundsIndex.
+   * Will override the defined `default` strategy.
+   */
+  | ContentStrategyKind<'sounds', NonNullable<SoundsIndexArguments['onConflict']>>
   /**
    * The conflict strategy to use for Waypoint styles.
    * Will override the defined `default` strategy.

package/src/utils.ts CHANGED Viewed

@@ -723,4 +723,4 @@ export type SmartRange<Min extends number, Max extends number> = (
       PositiveRange<Min, Max>
 )
-export type AllowConst<T> = T | Readonly<T>
+export type AllowConst<T> = T | Readonly<T>

package/src/variables/abstractClasses.ts CHANGED Viewed

@@ -1,5 +1,4 @@
 import type { JSONTextComponent } from 'sandstone/arguments/jsonTextComponent'
-import type { Node } from 'sandstone/core'
 import type { ConditionNode } from '../flow'
 import type { SelectorClass } from './Selector'
 import type { NBTSerializable } from 'sandstone/arguments'
@@ -25,15 +24,6 @@ export class ConditionClass {
    */
   declare readonly __conditionClassBrand: true
-  /**
-   * Optional commands that must run before this condition's predicate is evaluated.
-   * Conditions that emit side-effect commands at construction (e.g. `data.equals`
-   * building `execute store result ...`) capture them here so the visitor pass can
-   * re-emit them at the right location — inline before the IfNode, or inside the
-   * child MCFunction when AND/OR extracts. Optional; pure predicates leave it unset.
-   */
-  preNodes?: Node[]
   /**
    * @internal
    */