sandstone 1.1.4 → 1.2.0

package/src/flow/Flow.ts

@@ -1,8 +1,6 @@
 import type {
   Registry,
-  ContainerSlotSelector,
   Coordinates,
-  EntitySlotSelector,
   JSONTextComponent,
   MultipleEntitiesArgument,
   MultiplePlayersArgument,
@@ -11,6 +9,7 @@ import type {
   SymbolBlock,
   SymbolMcdocBlockStates,
 } from 'sandstone/arguments'
+import type { ItemSlotSource } from '../commands/implementations/world/item'
 import type {
   ConditionClass,
   DataPointClass,
@@ -21,7 +20,7 @@ import type {
 import { parseJSONText, Score } from 'sandstone/variables'
 import type { DataPointPickClass, MCFunctionClass, PredicateClass, SandstoneCore } from '../core'
 import type { LiteralUnion, NamespacedLiteralUnion } from '../utils'
-import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode } from './conditions'
+import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode, type SlotsBlockConditionNode, type SlotsEntityConditionNode } from './conditions'
 import type { ItemPredicate } from './conditions/variables/items'
 import { IfStatement } from './if_else'
 import type { ForOfIterator } from './loops'
@@ -58,17 +57,37 @@ export class Flow {
   if = (condition: Condition, callback: () => void) =>
     new IfStatement(this.sandstoneCore, conditionToNode(condition), callback)
 
-  and = (...conditions: Condition[]) =>
-    new AndNode(
+  /**
+   * Combine conditions with AND.
+   *
+   * Accepts either variadic conditions (`_.and(a, b, c)`) or a single array
+   * (`_.and([a, b, c])`, useful for `Array.prototype.map` results).
+   */
+  and(...conditions: Condition[]): AndNode
+  and(conditions: Condition[]): AndNode
+  and(...args: any[]): AndNode {
+    const conditions = (args[0] instanceof Array ? args[0] : args) as Condition[]
+    return new AndNode(
       this.sandstoneCore,
       conditions.map((condition) => conditionToNode(condition)),
     )
+  }
 
-  or = (...conditions: Condition[]) =>
-    new OrNode(
+  /**
+   * Combine conditions with OR.
+   *
+   * Accepts either variadic conditions (`_.or(a, b, c)`) or a single array
+   * (`_.or([a, b, c])`, useful for `Array.prototype.map` results).
+   */
+  or(...conditions: Condition[]): OrNode
+  or(conditions: Condition[]): OrNode
+  or(...args: any[]): OrNode {
+    const conditions = (args[0] instanceof Array ? args[0] : args) as Condition[]
+    return new OrNode(
       this.sandstoneCore,
       conditions.map((condition) => conditionToNode(condition)),
     )
+  }
 
   not = (condition: Condition) => new NotNode(this.sandstoneCore, conditionToNode(condition))
 
@@ -466,24 +485,57 @@ export class Flow {
      * Test for items in a block entity's inventory slots.
      *
      * @param sourcePos Position of the block entity to test.
-     * @param slots Slots to test (e.g., `'container.*'`, `'container.0'`).
+     * @param slotSource Slot source to test (e.g., `'container.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
     /**
      * Test for items in an entity's inventory slots.
      *
      * @param source Entity to test.
-     * @param slots Slots to test (e.g., `'inventory.*'`, `'hotbar.0'`, `'armor.chest'`).
+     * @param slotSource Slot source to test (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
+  } {
+    return {
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slotSource, itemPredicate),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slotSource, itemPredicate),
+    }
+  }
+
+  /**
+   * Counts slots from a slot source that are present in a block entity or entity.
+   *
+   * @example
+   * ```ts
+   * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+   * _.if(_.slots.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'armor.chest' }), () => { ... })
+   * ```
+   */
+  get slots(): {
+    /**
+     * Count slots from a slot source that are present in a block entity.
+     *
+     * @param sourcePos Position of the block entity to test.
+     * @param slotSource Slot source (e.g., `'container.*'`, inline slot source, or a slot source reference).
+     */
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource) => SlotsBlockConditionNode
+    /**
+     * Count slots from a slot source that are present in an entity.
+     *
+     * @param source Entity to test.
+     * @param slotSource Slot source (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
+     */
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) => SlotsEntityConditionNode
   } {
     return {
-      block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slots, itemPredicate),
-      entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slots, itemPredicate),
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsBlock(this.sandstoneCore, sourcePos, slotSource),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsEntity(this.sandstoneCore, source, slotSource),
     }
   }
 

package/src/flow/conditions/index.ts

@@ -11,6 +11,7 @@ import * as variables from './variables'
 export const SandstoneConditions = {
   Advancement: resources.AdvancementConditionNode,
   Predicate: resources.PredicateConditionNode,
+  SlotSource: resources.SlotSourceConditionNode,
   Tag: resources.TagConditionNode,
 
   Biome: variables.BiomeConditionNode,
@@ -20,6 +21,8 @@ export const SandstoneConditions = {
   Function: variables.FunctionConditionNode,
   ItemsBlock: variables.ItemsBlockConditionNode,
   ItemsEntity: variables.ItemsEntityConditionNode,
+  SlotsBlock: variables.SlotsBlockConditionNode,
+  SlotsEntity: variables.SlotsEntityConditionNode,
   Loaded: variables.LoadedConditionNode,
   DataPointExists: variables.DataPointExistsConditionNode,
   DataPointEquals: variables.DataPointEqualsConditionNode,

package/src/flow/conditions/resources/index.ts

@@ -1,3 +1,4 @@
 export * from './advancement'
 export * from './predicate'
+export * from './slotSource'
 export * from './tag'

package/src/flow/conditions/resources/slotSource.ts

@@ -0,0 +1,21 @@
+import type { SandstoneCore } from 'sandstone/core'
+import { SingleConditionNode } from '../condition'
+
+/**
+ * Condition node representing a slot source being tested against `@s`.
+ *
+ * Expands to `execute if slots entity @s <slotSource>`, which counts the number of slots from
+ * the slot source that are present on the executing entity.
+ */
+export class SlotSourceConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    public slotSource: string,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition(): unknown[] {
+    return ['slots', 'entity', '@s', this.slotSource]
+  }
+}

package/src/flow/conditions/variables/items.ts

@@ -1,7 +1,8 @@
-import type { Coordinates, ContainerSlotSelector, EntitySlotSelector, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
+import type { Coordinates, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
 import type { SandstoneCore } from 'sandstone/core/sandstoneCore'
 import { coordinatesParser, targetParser } from 'sandstone/variables'
 import type { ItemPredicateClass } from 'sandstone/variables/ItemPredicate'
+import type { ItemSlotSource } from '../../../commands/implementations/world/item'
 import { SingleConditionNode } from '../condition'
 
 /** Item predicate for matching items in inventory slots. */
@@ -14,20 +15,23 @@ export type ItemPredicate = Registry['minecraft:item'] | ItemPredicateClass
  * ```ts
  * // Check if chest has any diamonds
  * _.if(_.items.block(abs(0, 64, 0), 'container.*', 'minecraft:diamond'), () => { ... })
+ *
+ * // Check using an inline slot source
+ * _.if(_.items.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'container.0' }, 'minecraft:diamond'), () => { ... })
  * ```
  */
 export class ItemsBlockConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private sourcePos: Coordinates,
-    private slots: ContainerSlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'block', coordinatesParser(this.sourcePos), this.slots, `${this.itemPredicate}`]
+    return ['items', 'block', coordinatesParser(this.sourcePos), this.slotSource, `${this.itemPredicate}`]
   }
 }
 
@@ -44,13 +48,57 @@ export class ItemsEntityConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private source: MultipleEntitiesArgument,
-    private slots: EntitySlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'entity', targetParser(this.source), this.slots, `${this.itemPredicate}`]
+    return ['items', 'entity', targetParser(this.source), this.slotSource, `${this.itemPredicate}`]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on a block entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.block(abs(0, 64, 0), 'container.*'), () => { ... })
+ * ```
+ */
+export class SlotsBlockConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private sourcePos: Coordinates,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'block', coordinatesParser(this.sourcePos), this.slotSource]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on an entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+ * ```
+ */
+export class SlotsEntityConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private source: MultipleEntitiesArgument,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'entity', targetParser(this.source), this.slotSource]
   }
 }

package/src/pack/pack.ts

@@ -29,6 +29,7 @@ import type {
   ChatTypeClassArguments,
   DamageTypeClassArguments,
   DataPointPickClass,
+  DecoratedPotPatternClassArguments,
   DialogClassArguments,
   EnchantmentClassArguments,
   EnchantmentProviderClassArguments,
@@ -51,6 +52,7 @@ import type {
   PredicateClassArguments,
   RecipeClassArguments,
   ShaderClassArguments,
+  SlotSourceClassArguments,
   SoundEventArguments,
   SoundsIndexArguments,
   SulfurCubeArchetypeClassArguments,
@@ -77,6 +79,7 @@ import {
   BlockStateDefinitionClass,
   ChatTypeClass,
   DamageTypeClass,
+  DecoratedPotPatternClass,
   DialogClass,
   EnchantmentClass,
   EnchantmentProviderClass,
@@ -99,6 +102,7 @@ import {
   RecipeClass,
   SandstoneCore,
   ShaderClass,
+  SlotSourceClass,
   SoundEventClass,
   SoundsIndexClass,
   SulfurCubeArchetypeClass,
@@ -314,11 +318,11 @@ export class SandstonePack {
     }
     return {
       datapack: {
-        packFormat: 111,
+        packFormat: 112,
         description: 'A Sandstone datapack',
       },
       resourcepack: {
-        packFormat: 92,
+        packFormat: 93,
         description: 'A Sandstone resource pack',
       },
     }
@@ -444,7 +448,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('datapack') as DataPack
 
     if (!pack) {
-      const options = this.packOptions.datapack ?? { packFormat: 111, description: 'A Sandstone datapack' }
+      const options = this.packOptions.datapack ?? { packFormat: 112, description: 'A Sandstone datapack' }
       pack = this.packTypes.set('datapack', new DataPack(false, options)).get('datapack') as DataPack
     }
 
@@ -455,7 +459,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('resourcepack') as ResourcePack
 
     if (!pack) {
-      const options = this.packOptions.resourcepack ?? { packFormat: 92, description: 'A Sandstone resource pack' }
+      const options = this.packOptions.resourcepack ?? { packFormat: 93, description: 'A Sandstone resource pack' }
       pack = this.packTypes
         .set('resourcepack', new ResourcePack(options))
         .get('resourcepack') as ResourcePack
@@ -1121,6 +1125,15 @@ export class SandstonePack {
       ...options,
     })
 
+  DecoratedPotPattern = (name: string, decoratedPotPattern: DecoratedPotPatternClassArguments['json'], options?: Omit<Partial<DecoratedPotPatternClassArguments>, 'json'>) =>
+    new DecoratedPotPatternClass(this.core, name, {
+      json: decoratedPotPattern,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('decorated_pot_pattern') as DecoratedPotPatternClassArguments['onConflict'],
+      ...options,
+    })
+
   ItemModifier = (name: string, itemModifier: ItemModifierClassArguments['json'], options?: Omit<Partial<ItemModifierClassArguments>, 'json'>) =>
     new ItemModifierClass(this.core, name, {
       json: itemModifier,
@@ -1161,6 +1174,15 @@ export class SandstonePack {
       ...options,
     })
 
+  SlotSource = (name: string, slotSource: SlotSourceClassArguments['json'], options?: Omit<Partial<SlotSourceClassArguments>, 'json'>) =>
+    new SlotSourceClass(this.core, name, {
+      json: slotSource,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('slot_source') as SlotSourceClassArguments['onConflict'],
+      ...options,
+    })
+
   SulfurCubeArchetype = (name: string, sulfurCubeArchetype: SulfurCubeArchetypeClassArguments['json'], options?: Omit<Partial<SulfurCubeArchetypeClassArguments>, 'json'>) =>
     new SulfurCubeArchetypeClass(this.core, name, {
       json: sulfurCubeArchetype,
@@ -1355,7 +1377,7 @@ export class SandstonePack {
       json,
       creator: 'user',
       addToSandstoneCore: true,
-      onConflict: conflictDefaults('block_definition') as BlockStateDefinitionArguments<JSON>['onConflict'],
+      onConflict: conflictDefaults('blockstate') as BlockStateDefinitionArguments<JSON>['onConflict'],
       ...options,
     })
   }

package/src/sandstone.ts

@@ -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.