sandstone 1.0.0 → 1.0.2

package/src/pack/visitors/optimizeMacroTemporaries.ts

@@ -0,0 +1,200 @@
+import { DataCommandNode, ExecuteCommandNode, FunctionCommandNode, type SubCommand } from 'sandstone/commands'
+import type { MCFunctionNode, Node } from 'sandstone/core'
+import { CommandNode, ContainerCommandNode, ContainerNode } from 'sandstone/core'
+import { GenericSandstoneVisitor } from './visitor'
+
+type StoragePoint = {
+  target: string
+  path: string
+}
+
+type MacroCopy = {
+  destination: StoragePoint
+  source: StoragePoint
+}
+
+type Producer = {
+  index: number
+  store: SubCommand
+  destination: StoragePoint
+}
+
+const flattenArgs = (args: unknown[]): unknown[] =>
+  args.flatMap((arg) => Array.isArray(arg) ? flattenArgs(arg) : [arg])
+
+const referencesStoragePoint = (node: Node, point: StoragePoint): number => {
+  let references = 0
+
+  if (node instanceof CommandNode) {
+    const args = flattenArgs(node.args)
+    for (let i = 0; i < args.length - 1; i++) {
+      if (args[i] === point.target && args[i + 1] === point.path) {
+        references++
+      }
+    }
+  }
+
+  if (node instanceof ContainerNode || node instanceof ContainerCommandNode) {
+    for (const child of node.body) {
+      references += referencesStoragePoint(child, point)
+    }
+  }
+
+  return references
+}
+
+const getMacroCopy = (node: Node, macroPoint: StoragePoint): MacroCopy | undefined => {
+  if (!(node instanceof DataCommandNode)) {
+    return undefined
+  }
+
+  const args = node.args
+  if (
+    args[0] !== 'modify'
+    || args[1] !== 'storage'
+    || args[2] !== macroPoint.target
+    || args[4] !== 'set'
+    || args[5] !== 'from'
+    || args[6] !== 'storage'
+    || typeof args[3] !== 'string'
+    || typeof args[7] !== 'string'
+    || typeof args[8] !== 'string'
+  ) {
+    return undefined
+  }
+
+  const parameterPrefix = macroPoint.path ? `${macroPoint.path}.` : ''
+  const destinationPath = args[3]
+  const localPath = destinationPath.slice(parameterPrefix.length)
+  if (
+    !destinationPath.startsWith(parameterPrefix)
+    || (!localPath.startsWith('param_') && !localPath.startsWith('env_'))
+  ) {
+    return undefined
+  }
+
+  return {
+    destination: { target: macroPoint.target, path: destinationPath },
+    source: { target: args[7], path: args[8] },
+  }
+}
+
+const isMacroReset = (node: Node, macroPoint: StoragePoint) => {
+  if (!(node instanceof DataCommandNode)) {
+    return false
+  }
+
+  const args = node.args
+  return args[0] === 'modify'
+    && args[1] === 'storage'
+    && args[2] === macroPoint.target
+    && args[3] === macroPoint.path
+    && args[4] === 'set'
+    && args[5] === 'value'
+    && `${args[6]}` === '{}'
+}
+
+const getExecuteStore = (node: Node, source: StoragePoint) => {
+  if (!(node instanceof ExecuteCommandNode)) {
+    return undefined
+  }
+
+  const hasStoreResult = node.args.some((arg) => arg[0] === 'store')
+    && node.args.some((arg) => arg[0] === 'result')
+  if (!hasStoreResult) {
+    return undefined
+  }
+
+  return node.args.find((arg) =>
+    arg[0] === 'storage'
+    && arg[1] === source.target
+    && arg[2] === source.path
+  )
+}
+
+/**
+ * Writes one-use data temporaries directly into the compound passed to a macro
+ * MCFunction, avoiding a second round of `data modify ... set from` commands.
+ */
+export class OptimizeMacroTemporariesVisitor extends GenericSandstoneVisitor {
+  visitMCFunctionNode = (functionNode: MCFunctionNode) => {
+    this.genericVisit(functionNode)
+
+    for (let callIndex = 0; callIndex < functionNode.body.length; callIndex++) {
+      const call = functionNode.body[callIndex]
+      if (!(call instanceof FunctionCommandNode)) {
+        continue
+      }
+
+      const callArgs = call.args as unknown[]
+      if (
+        callArgs[1] !== 'with'
+        || callArgs[2] !== 'storage'
+        || typeof callArgs[3] !== 'string'
+        || typeof callArgs[4] !== 'string'
+      ) {
+        continue
+      }
+
+      const macroPoint = { target: callArgs[3], path: callArgs[4] }
+      const copies: MacroCopy[] = []
+      let setupStart = callIndex
+
+      while (setupStart > 0) {
+        const copy = getMacroCopy(functionNode.body[setupStart - 1], macroPoint)
+        if (!copy) {
+          break
+        }
+        copies.unshift(copy)
+        setupStart--
+      }
+
+      if (copies.length === 0 || setupStart === 0 || !isMacroReset(functionNode.body[setupStart - 1], macroPoint)) {
+        continue
+      }
+
+      const resetIndex = setupStart - 1
+      const producers: Producer[] = []
+      let canOptimize = true
+
+      for (const copy of copies) {
+        const matches: { index: number; store: SubCommand }[] = []
+        for (const [index, node] of functionNode.body.slice(0, resetIndex).entries()) {
+          const store = getExecuteStore(node, copy.source)
+          if (store) {
+            matches.push({ index, store })
+          }
+        }
+
+        if (
+          matches.length !== 1
+          || referencesStoragePoint(functionNode, copy.source) !== 2
+        ) {
+          canOptimize = false
+          break
+        }
+
+        producers.push({ ...matches[0], destination: copy.destination })
+      }
+
+      if (!canOptimize) {
+        continue
+      }
+
+      const producerIndexes = new Set(producers.map((producer) => producer.index))
+      if (producerIndexes.size !== producers.length) {
+        continue
+      }
+
+      for (const producer of producers) {
+        producer.store[1] = producer.destination.target
+        producer.store[2] = producer.destination.path
+      }
+
+      functionNode.body.splice(resetIndex, copies.length + 1)
+      callIndex = resetIndex
+    }
+
+    return functionNode
+  }
+}

package/src/sandstone.ts

@@ -1,11 +1,11 @@
 import type { JSONTextComponent } from './arguments/jsonTextComponent'
 import type { SandstoneContext } from './context'
-import type { FillCommand, SetBlockCommand } from './commands'
+import type { FillCommand, GiveCommand, SetBlockCommand } from './commands'
 import type {
   AdvancementClassArguments,
   AtlasClassArguments,
   BannerPatternClassArguments,
-  BlockStateArguments,
+  BlockStateDefinitionArguments,
   ChatTypeClassArguments,
   DamageTypeClassArguments,
   DialogClassArguments,
@@ -28,6 +28,7 @@ import type {
   RecipeClassArguments,
   ShaderClassArguments,
   SoundEventArguments,
+  SoundsIndexArguments,
   TagClassArguments,
   TestEnvironmentClassArguments,
   TestInstanceClassArguments,
@@ -104,8 +105,8 @@ export { ResolveNBTPart }
 
 // Commands must go through sandstonePack.commands at call time for the same reason as pack methods.
 type SandstoneCommands = SandstonePack['commands']
-// Exclude setblock since it needs explicit type annotation due to complex generics
-type CommandKeys = Exclude<keyof SandstoneCommands, 'setblock' | 'fill'>
+// Exclude a few commands that need explicit type annotation due to complex generics
+type CommandKeys = Exclude<keyof SandstoneCommands, 'give' | 'setblock' | 'fill'>
 
 // Creates a proxy that handles both callable commands and object-based commands.
 // This avoids hardcoding which commands are object-based by detecting at runtime.
@@ -161,7 +162,6 @@ export const {
   forceload,
   gamemode,
   gamerule,
-  give,
   help,
   kill,
   list,
@@ -216,6 +216,10 @@ export const {
   tell,
 } = commandsProxy
 
+// give needs explicit type annotation due to complex generics
+export const give: GiveCommand<false>['give'] = ((...args: unknown[]) =>
+  (sandstonePack.commands.give as CallableFunction)(...args)) as GiveCommand<false>['give']
+
 // setblock needs explicit type annotation due to complex generics
 export const setblock: SetBlockCommand<false>['setblock'] = ((...args: unknown[]) =>
   (sandstonePack.commands.setblock as CallableFunction)(...args)) as SetBlockCommand<false>['setblock']
@@ -310,7 +314,7 @@ export const {
   WorldClock,
 
   Atlas,
-  BlockState,
+  BlockStateDefinition,
   Equipment,
   Font,
   ItemModelDefinition,
@@ -320,6 +324,7 @@ export const {
   PostEffect,
   Shader,
   SoundEvent,
+  SoundsIndex,
   PlainText,
   Texture,
   WaypointStyle,
@@ -347,7 +352,36 @@ export const {
   defaultNamespace,
 } = packMethodsProxy
 
-export * from './variables/nbt/NBTs'
+// 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 {
@@ -393,7 +427,7 @@ export {
 
   // Resourcepack resources
   AtlasClass,
-  BlockStateClass,
+  BlockStateDefinitionClass,
   EquipmentClass,
   FontClass,
   ItemModelDefinitionClass,
@@ -402,6 +436,7 @@ export {
   ParticleClass,
   PostEffectClass,
   SoundEventClass,
+  SoundsIndexClass,
   TextureClass,
   WaypointStyleClass,
 } from './core/resources'
@@ -507,6 +542,8 @@ type PackConfigs<PackType extends LiteralUnion<'datapack' | 'resourcepack'>> = R
   PackType extends 'datapack' ? DatapackConfig : PackType extends 'resourcepack' ? ResourcePackConfig : unknown
 >
 
+export type HandlerFile = string | ArrayBuffer | Buffer
+
 export interface SandstoneConfig {
   /**
    * The default namespace for the packs.
@@ -607,7 +644,7 @@ export interface SandstoneConfig {
     handle?: {
       path: RegExp
 
-      callback: (contents: string | Buffer | Promise<Buffer>) => Promise<Buffer>
+      callback: (contents: HandlerFile | Promise<HandlerFile>) => HandlerFile | Promise<HandlerFile>
     }[]
   }
 }
@@ -761,7 +798,7 @@ type ContentStrategy =
    * The conflict strategy to use for Block states.
    * Will override the defined `default` strategy.
    */
-  | ContentStrategyKind<'block_state', NonNullable<BlockStateArguments<any>['onConflict']>>
+  | ContentStrategyKind<'block_definition', NonNullable<BlockStateDefinitionArguments<any>['onConflict']>>
   /**
    * The conflict strategy to use for Fonts.
    * Will override the defined `default` strategy.

package/src/utils.ts

@@ -4,23 +4,12 @@
 import type { Static } from '@sinclair/typebox'
 import { FormatRegistry, Type } from '@sinclair/typebox'
 import fs from 'fs-extra'
-import type FetchType from 'node-fetch'
-import type { Response } from 'node-fetch'
 import { coerce } from 'semver'
 import * as util from 'util'
 import type { MultipleEntitiesArgument } from './arguments/selector'
 import type { Node } from './core/nodes'
 import type { UUIDinNumber } from './variables/UUID'
 
-/* @ts-ignore */
-export const fetch: (input: URL | RequestInfo, init?: RequestInit | undefined) => Promise<Response> = Object.hasOwn(
-  globalThis,
-  'fetch',
-)
-  ? globalThis.fetch
-  : async (...args: Parameters<typeof FetchType>) =>
-    (await import('node-fetch')).default(...args) as unknown as Promise<Response>
-
 /**
  * Allows to get autocompletion on string unions, while still allowing generic strings.
  * @see https://github.com/microsoft/TypeScript/issues/29729#issuecomment-700527227
@@ -125,6 +114,7 @@ export type WithMCNamespace<T extends string> = `minecraft:${T}` | T
 
 export function makeCallableProxy(func: any, object: any) {
   return new Proxy(func, {
+    apply: (_t, _thisArg, args) => Reflect.apply(func, object, args),
     get: (_t, p, _r) => object[p],
     set: (_t, p, value, _r) => {
       object[p] = value
@@ -731,4 +721,6 @@ export type SmartRange<Min extends number, Max extends number> = (
       : ToNegative<PositiveRange<1, Abs<Min>>> | 0 | PositiveRange<1, Max>
     :
       PositiveRange<Min, Max>
-)
+)
+
+export type AllowConst<T> = T | (readonly [T])[0]

package/src/variables/Coordinates.ts

@@ -22,7 +22,7 @@ export class VectorClass<T extends readonly unknown[]> implements NBTSerializabl
   }
 
   toNBT() {
-    return this.toString()
+    return `'${this.toString()}'`
   }
 
   [Symbol.iterator](): Iterator<T[0]> {
@@ -48,7 +48,7 @@ type MappedArray<T, U> = { [key in keyof T]: U }
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function absolute(coordinate?: number): string
+export function absolute<T extends number>(coordinate?: T): `${T}`
 
 /**
  * Transforms numbers into absolute coordinates.
@@ -65,14 +65,14 @@ export function absolute(coordinate?: number): string
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function absolute<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, string>>
+export function absolute<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `${number}`>>
 
-export function absolute<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function absolute<T extends Tuple<number>>(...coordinates: T): `${T[0]}`| VectorClass<MappedArray<T, `${number}`>> {
   if (coordinates.length === 1) {
-    return coordinates[0].toString()
+    return coordinates[0].toString() as `${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => coord.toString()) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => coord.toString()) as unknown as MappedArray<T, `${number}`>)
 }
 
 /**
@@ -109,7 +109,7 @@ export function relative<T extends [0, 0, 0]>(): VectorClass<MappedArray<T, '~'>
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function relative(coordinate: number): `~${string}`
+export function relative<T extends number>(coordinate: T): `~${T}`
 
 /**
  * Transforms numbers into relative coordinates, using the tilde notation `~`.
@@ -128,18 +128,18 @@ export function relative(coordinate: number): `~${string}`
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link local} for local coordinates (e.g. `^10`)
  */
-export function relative<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `~${string}`>>
+export function relative<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `~${number | ''}`>>
 
-export function relative<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function relative<T extends Tuple<number>>(...coordinates: T): '~' | `~${T[0]}`| VectorClass<MappedArray<T, `~${number | ''}`>> {
   if (coordinates.length === 0) {
-    return new VectorClass(['~', '~', '~'] as unknown as MappedArray<T, string>)
+    return new VectorClass(['~', '~', '~'] as unknown as MappedArray<T, `~${number | ''}`>)
   }
 
   if (coordinates.length === 1) {
-    return `~${coordinates[0] || ''}`
+    return `~${coordinates[0]}` as `~${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => `~${coord || ''}`) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => `~${coord || ''}`) as unknown as MappedArray<T, `~${number | ''}`>)
 }
 
 /**
@@ -178,7 +178,7 @@ export function local<T extends [0, 0, 0]>(): VectorClass<MappedArray<T, '^'>>
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  */
-export function local(coordinate: number): `^${string}`
+export function local<T extends number>(coordinate: T): `^${T}`
 
 /**
  * Transforms numbers into local coordinates, using the tilde notation `^`.
@@ -199,16 +199,16 @@ export function local(coordinate: number): `^${string}`
  * @see {@link absolute} for absolute coordinates (e.g. `10`)
  * @see {@link relative} for relative coordinates (e.g. `~10`)
  */
-export function local<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `^${string}`>>
+export function local<T extends Tuple<number>>(...coordinates: T): VectorClass<MappedArray<T, `^${number | ''}`>>
 
-export function local<T extends Tuple<number>>(...coordinates: T): string | VectorClass<MappedArray<T, string>> {
+export function local<T extends Tuple<number>>(...coordinates: T): `^${T[0]}` | VectorClass<MappedArray<T, `^${number | ''}`>> {
   if (coordinates.length === 0) {
-    return new VectorClass(['^', '^', '^'] as unknown as MappedArray<T, string>)
+    return new VectorClass(['^', '^', '^'] as unknown as MappedArray<T, '^'>)
   }
 
   if (coordinates.length === 1) {
-    return `^${coordinates[0] || ''}`
+    return `^${coordinates[0]}` as `^${T[0]}`
   }
 
-  return new VectorClass(coordinates.map((coord) => `^${coord || ''}`) as unknown as MappedArray<T, string>)
+  return new VectorClass(coordinates.map((coord) => `^${coord || ''}`) as unknown as MappedArray<T, `^${number | ''}`>)
 }

package/src/variables/Data.ts

@@ -139,6 +139,9 @@ export class DataClass<TYPE extends DATA_TYPES = any> {
 export class DataPointClass<TYPE extends DATA_TYPES = any>
   extends MacroArgument
   implements ConditionTextComponentClass, NBTSerializable {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   path
 
   currentTarget: DATA_TARGET[TYPE]
@@ -311,6 +314,9 @@ export class DataPointClass<TYPE extends DATA_TYPES = any>
 }
 
 export class StringDataPointClass<TYPE extends DATA_TYPES = any> extends DataPointClass {
+  declare readonly __textComponentClassBrand: true
+  declare readonly __conditionClassBrand: true
+
   readonly sliceBounds: [number] | [number, number]
 
   constructor(

package/src/variables/DataSets.ts

@@ -45,7 +45,7 @@ type GetKeys<T> = T extends unknown[]
       : number // other array
   : keyof T // not an array
 
-export type DataIndexMapInitial = RootNBT | Record<string, DataPointClass | DataPointPickClass>
+export type DataIndexMapInitial = RootNBT | Record<`${any}${string}`, DataPointClass | DataPointPickClass>
 
 export class DataIndexMapClass<INITIAL extends DataIndexMapInitial> extends IterableDataClass<'map'> {
   entries: Record<string, number> = {}
@@ -456,7 +456,7 @@ export class DataArrayClass<INITIAL extends DataArrayInitial> extends IterableDa
   }
 }
 
-export function DataIndexMap<INITIAL extends DataIndexMapInitial>(
+export function DataIndexMapInternal<INITIAL extends DataIndexMapInitial>(
   pack: SandstonePack,
   initialize: INITIAL,
   dataPoint?: DataPointClass<'storage'>,
@@ -481,16 +481,16 @@ export function DataIndexMap<INITIAL extends DataIndexMapInitial>(
 
       return true
     },
-  }) as DataIndexMapClass<INITIAL> & { [K in keyof INITIAL]: DataIndexMapInitial[string] } & {
-    [K in string]: DataIndexMapInitial[string]
+  }) as DataIndexMapClass<INITIAL> & { [K in keyof INITIAL]: DataIndexMapInitial[`${any}${string}`] } & {
+    [K in string]: DataIndexMapInitial[`${any}${string}`]
   }
 }
 
-export type DataIndexMap<INITIAL extends DataIndexMapInitial> = DataIndexMapClass<INITIAL> & {
-  [K in keyof INITIAL]: DataIndexMapInitial[string]
-} & { [K in string]: DataIndexMapInitial[string] }
+export type DataIndexMapType<INITIAL extends DataIndexMapInitial> = DataIndexMapClass<INITIAL> & {
+  [K in keyof INITIAL]: DataIndexMapInitial[`${any}${string}`]
+} & { [K in string]: DataIndexMapInitial[`${any}${string}`] }
 
-export function DataArray<INITIAL extends DataArrayInitial>(
+export function DataArrayInternal<INITIAL extends DataArrayInitial>(
   pack: SandstonePack,
   initialize: INITIAL,
   dataPoint?: DataPointClass<'storage'>,
@@ -520,6 +520,6 @@ export function DataArray<INITIAL extends DataArrayInitial>(
   }
 }
 
-export type DataArray<INITIAL extends DataArrayInitial> = DataArrayClass<INITIAL> & {
+export type DataArrayType<INITIAL extends DataArrayInitial> = DataArrayClass<INITIAL> & {
   [K in keyof INITIAL]: DataArrayInitial[number]
 } & { [K in number]: DataArrayInitial[number] }

package/src/variables/ItemPredicate.ts

@@ -174,7 +174,7 @@ export class ItemPredicateClass {
    * ```
    */
   model(): ItemModelBuilder {
-    // Dynamic import to avoid circular dependency
+    // Dynamic import to avoid circular dependency // TODO: Fix
     const { ItemModelBuilder } = require('sandstone/core/resources/resourcepack/itemDefinition')
     const builder = new ItemModelBuilder(this.pack)
     // Copy test groups to the new builder