sandstone 1.1.1 → 1.1.3

package/src/core/resources/resourcepack/text.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-lone-blocks */
 
-import type { ContentTag, JSONTextComponent } from 'sandstone/arguments'
+import type { JSONTextComponent } from 'sandstone/arguments'
 import { JSONTextComponentClass } from 'sandstone/variables'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
@@ -71,60 +71,62 @@ export class PlainTextClass extends ResourceClass<PlainTextNode> implements List
         converted += this.componentToPlainText(_text)
       }
     } else {
-      const currentText = text as ContentTag<'text'>
+      const currentText = text
 
-      if (!currentText.text) {
-        throw new Error('Dynamic JSON content is not supported in plaintext')
-      }
+      if (typeof currentText !== 'string') {
+        if (!('text' in currentText)) {
+          throw new Error('Dynamic JSON content is not supported in plaintext')
+        }
 
-      if (currentText.color) {
-        const { color } = currentText
-        if (color.startsWith('#')) {
-          throw new Error('Hex codes are not supported in plaintext')
+        if (currentText.color) {
+          const { color } = currentText
+          if (color.startsWith('#')) {
+            throw new Error('Hex codes are not supported in plaintext')
+          }
+          // eslint-disable-next-line max-len
+          const colors = [
+            'black',
+            'dark_blue',
+            'dark_green',
+            'dark_aqua',
+            'dark_red',
+            'dark_purple',
+            'gold',
+            'gray',
+            'dark_gray',
+            'blue',
+            'green',
+            'aqua',
+            'red',
+            'light_purple',
+            'yellow',
+            'white',
+          ] as const
+
+          converted = `§${colors.indexOf(color as 'black').toString(16)}`
         }
-        // eslint-disable-next-line max-len
-        const colors = [
-          'black',
-          'dark_blue',
-          'dark_green',
-          'dark_aqua',
-          'dark_red',
-          'dark_purple',
-          'gold',
-          'gray',
-          'dark_gray',
-          'blue',
-          'green',
-          'aqua',
-          'red',
-          'light_purple',
-          'yellow',
-          'white',
-        ] as const
-
-        converted = `§${colors.indexOf(color as 'black').toString(16)}`
-      }
 
-      if (currentText.obfuscated) {
-        converted += '§k'
-      }
-      if (currentText.bold) {
-        converted += '§l'
-      }
-      if (currentText.strikethrough) {
-        converted += '§m'
-      }
-      if (currentText.underlined) {
-        converted += '§n'
-      }
-      if (currentText.italic) {
-        converted += '§o'
-      }
+        if (currentText.obfuscated) {
+          converted += '§k'
+        }
+        if (currentText.bold) {
+          converted += '§l'
+        }
+        if (currentText.strikethrough) {
+          converted += '§m'
+        }
+        if (currentText.underlined) {
+          converted += '§n'
+        }
+        if (currentText.italic) {
+          converted += '§o'
+        }
 
-      converted += `${currentText.text}`
+        converted += `${currentText.text}`
 
-      if (currentText.extra) {
-        converted += this.componentToPlainText(currentText.extra)
+        if (currentText.extra) {
+          converted += this.componentToPlainText(currentText.extra as JSONTextComponent)
+        }
       }
     }
 

package/src/core/resources/resourcepack/texture.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource, type TEXTURE_TYPES } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource, type TEXTURE_TYPES } from 'sandstone/arguments'
 import type { LiteralUnion } from 'sandstone/utils'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
@@ -7,7 +7,7 @@ import { ResourceClass } from '../resource'
 
 type TextureType = LiteralUnion<TEXTURE_TYPES>
 
-type TextureMetaAll = SymbolResource['texture_meta']
+type TextureMetaAll = MCDocToJSON<SymbolResource['texture_meta']>
 
 // TODO: Find which texture types actually support animations.
 type TextureMeta<Type extends TextureType> = (
@@ -35,14 +35,14 @@ export type TextureArguments<Type extends TextureType> = {
   /**
    * The texture's buffer.
    */
-  texture?: Promise<Buffer> | Buffer
+  texture?: Promise<ArrayBuffer | Buffer> | ArrayBuffer | Buffer
 
   sprite?: boolean | string
 
   meta?: TextureMeta<Type>
 } & ResourceClassArguments<'default'>
 
-export class TextureClass<Type extends TextureType = 'block'> extends ResourceClass<TextureNode<Type>> {
+export class TextureClass<Type extends TextureType> extends ResourceClass<TextureNode<Type>> {
   static readonly resourceType = 'texture'
 
   type: Type
@@ -81,7 +81,7 @@ export class TextureClass<Type extends TextureType = 'block'> extends ResourceCl
   }
 
   toString() {
-    return `${this.path[0]}:${this.path.slice(2)}`
+    return `${this.path[0]}:${this.path.slice(2).join('/')}`
   }
 
   // TODO

package/src/core/resources/resourcepack/waypointStyle.ts

@@ -1,4 +1,4 @@
-import { RESOURCE_PATHS, type SymbolResource } from 'sandstone/arguments'
+import { RESOURCE_PATHS, type MCDocToJSON, type SymbolResource } from 'sandstone/arguments'
 import { ContainerNode } from '../../nodes'
 import type { SandstoneCore } from '../../sandstoneCore'
 import type { ResourceClassArguments, ResourceNode } from '../resource'
@@ -22,7 +22,7 @@ export type WaypointStyleClassArguments = {
   /**
    * The waypoint style's JSON.
    */
-  json: SymbolResource[(typeof WaypointStyleClass)['resourceType']]
+  json: MCDocToJSON<SymbolResource[(typeof WaypointStyleClass)['resourceType']]>
 } & ResourceClassArguments<'default'>
 
 export class WaypointStyleClass extends ResourceClass<WaypointStyleNode> {

package/src/core/sandstoneCore.ts

@@ -11,7 +11,7 @@ import type { AwaitNode } from './nodes'
 import type { _RawMCFunctionClass, MCFunctionClass, MCFunctionNode } from './resources/datapack/mcfunction'
 import type { TagClass } from './resources/datapack/tag'
 import { SmithedDependencyClass } from './resources/dependency'
-import type { SoundsClass } from './resources/resourcepack/sound'
+import type { SoundsIndexClass } from './resources/resourcepack/sound'
 import { type ResourceClass, ResourceNodesMap } from './resources/resource'
 import { SmithedDependencyCache } from './smithed'
 import type { GenericCoreVisitor } from './visitors'
@@ -36,7 +36,7 @@ export class SandstoneCore {
   functionTags: Map<string, TagClass<'function'>> = new Map()
 
   /** Cache of auto-generated sounds.json definitions, keyed by namespace. Cleared on reset. */
-  sounds: Map<string, SoundsClass> = new Map()
+  sounds: Map<string, SoundsIndexClass> = new Map()
 
   /** Cache of auto-generated polling trigger check functions, keyed by polling interval. Cleared on reset. */
   checkTriggers: Record<number, MCFunctionClass<undefined, undefined>> = {}
@@ -127,18 +127,18 @@ export class SandstoneCore {
 
   async getExistingResource(relativePath: string): Promise<string>
 
-  async getExistingResource(relativePath: string, encoding: false): Promise<Buffer>
+  async getExistingResource(relativePath: string, encoding: false): Promise<ArrayBuffer | Buffer>
 
   async getExistingResource(relativePath: string, encoding: fs.EncodingOption): Promise<Buffer | string>
 
   async getExistingResource(resource: ResourceClass, encoding?: 'utf-8'): Promise<string>
 
-  async getExistingResource(resource: ResourceClass, encoding: false | fs.EncodingOption): Promise<Buffer>
+  async getExistingResource(resource: ResourceClass, encoding: false | fs.EncodingOption): Promise<ArrayBuffer | Buffer>
 
   async getExistingResource(
     pathOrResource: string | ResourceClass,
     encoding: false | fs.EncodingOption = 'utf-8',
-  ): Promise<Buffer | string> {
+  ): Promise<ArrayBuffer | Buffer | string> {
     if (typeof pathOrResource === 'string') {
       if (encoding === false) {
         return fs.readFile(pathOrResource)
@@ -171,13 +171,13 @@ export class SandstoneCore {
 
   async getVanillaResource(relativePath: string, text: true, type: 'client' | 'server'): Promise<string>
 
-  async getVanillaResource(relativePath: string, text: false, type: 'client' | 'server'): Promise<Buffer>
+  async getVanillaResource(relativePath: string, text: false, type: 'client' | 'server'): Promise<ArrayBuffer | Buffer>
 
   async getVanillaResource(
     relativePath: string,
     text = true,
     type: 'client' | 'server' = 'server',
-  ): Promise<string | Buffer> {
+  ): Promise<string | ArrayBuffer | Buffer> {
     return this.mcMetaCache.get(type === 'server' ? 'data' : 'assets', relativePath, text as true)
   }
 

package/src/core/smithed.ts

@@ -5,7 +5,7 @@ import AdmZip from 'adm-zip'
 import fs from 'fs-extra'
 import { getSandstoneContext } from 'sandstone/context'
 import type { PackData } from 'sandstone/utils'
-import { fetch, safeWrite } from 'sandstone/utils'
+import { safeWrite } from 'sandstone/utils'
 import type { SandstoneCore } from './sandstoneCore'
 import { DataPackDependencies, ResourcePackDependencies } from 'sandstone/pack'
 import { SmithedDependencyClass } from './resources/dependency'
@@ -15,8 +15,8 @@ type Manifest = Record<string, string>
 export type Dependency = {
   version: string
   date: number
-  datapack: () => Promise<Buffer>
-  resourcepack?: (() => Promise<Buffer>) | false
+  datapack: () => Promise<ArrayBuffer | Buffer>
+  resourcepack?: (() => Promise<ArrayBuffer | Buffer>) | false
 }
 
 type LockFile = Record<string, { version: string; date: number; resourcepack: boolean }>
@@ -199,12 +199,12 @@ export class SmithedDependencyCache {
       let files: AdmZip.IZipEntry[] | undefined = zip.getEntries()
 
       await safeWrite(path.join(this.path, dependency, 'datapack.zip'), await new Promise((res) => {
-        files![0].getDataAsync((data) => res(data as Buffer))
+        files![0].getDataAsync((data) => res(data))
       }))
 
       if (hasResourcePack) {
         await safeWrite(path.join(this.path, dependency, 'resourcepack.zip'), await new Promise((res) => {
-          files![1].getDataAsync((data) => res(data as Buffer))
+          files![1].getDataAsync((data) => res(data))
         }))
       }
 

package/src/flow/Flow.ts

@@ -129,10 +129,10 @@ export class Flow {
 
     const fullError: JSONTextComponent = [
       { text: '\nSandstone Pack Error:\n', color: 'yellow' },
-      error || '[Function Threw]',
-      '\n\n',
+      typeof error === 'string' ? { text: error } : error ?? { text: '[Function Threw]' },
+      { text: '\n\n'},
 
-      `@ Function ${node.resource.name}. Node ${node.body.length - 1}.\n`,
+      { text: `@ Function ${node.resource.name}. Node ${node.body.length - 1}.\n` },
     ]
 
     if (broadcast !== false) {
@@ -285,23 +285,19 @@ export class Flow {
     executeSwitch(this.sandstoneCore, value, cases)
   }
 
-  /** Create a static value case for switch statements */
-  case(value: number, callback: () => any): CaseStatement<number>
-
-  /** Create a static value case for switch statements */
-  case(value: NBTObject, callback: () => any): CaseStatement<NBTObject>
-
-  /** Create a condition case for switch statements - checked after static cases fail */
-  case<SwitchValueType>(condition: ConditionCallback<SwitchValueType>, callback: () => any): CaseStatement<never, SwitchValueType>
-
-  case<SwitchValueType>(value: number | NBTObject | ConditionCallback<SwitchValueType>, callback: () => any) {
+  case<SwitchValueType extends DataPointClass | DataPointPickClass | Score>(value: (SwitchValueType extends Score ? number : NBTObject) | ConditionCallback<SwitchValueType>, callback: () => any) {
     if (typeof value === 'function') {
-      return new CaseStatement<never, SwitchValueType>([
+      return new CaseStatement<SwitchValueType extends Score ? number : NBTObject, SwitchValueType>([
         { type: 'condition', condition: value, callback },
       ])
     }
-    return new CaseStatement([
-      { type: 'static', value, callback },
+    return new CaseStatement<SwitchValueType extends Score ? number : NBTObject, SwitchValueType>([
+      {
+        type: 'static',
+        /* @ts-ignore */
+        value,
+        callback
+      },
     ])
   }
 

package/src/flow/switch_case.ts

@@ -29,12 +29,12 @@ export type ConditionCase<ValueType> = readonly ['case', ConditionCallback<Value
 /** Either a static or condition case */
 export type SwitchCase<ValueType, CheckType> = StaticCase<CheckType> | ConditionCase<ValueType>
 
-export type DefaultType<ValueType extends number | NBTObject, SwitchValueType = unknown> = {
+export type DefaultType<ValueType extends number | NBTObject, SwitchValueType extends DataPointClass | DataPointPickClass | Score> = {
   entries: CaseEntry<SwitchValueType, ValueType>[]
   default: () => any
 }
 
-export class CaseStatement<ValueType extends number | NBTObject, SwitchValueType = unknown> {
+export class CaseStatement<ValueType extends number | NBTObject, SwitchValueType extends DataPointClass | DataPointPickClass | Score> {
   constructor(
     readonly entries: CaseEntry<SwitchValueType, ValueType>[] = [],
   ) {}
@@ -53,15 +53,15 @@ export class CaseStatement<ValueType extends number | NBTObject, SwitchValueType
   case(value: ValueType, callback: () => any): CaseStatement<ValueType, SwitchValueType>
 
   /** Add a condition case - checked after static cases fail. Use generic to specify switch value type on first condition: `.case<Score>(v => ...)` */
-  case<T = SwitchValueType>(condition: ConditionCallback<T>, callback: () => any): CaseStatement<ValueType, T>
+  case(condition: ConditionCallback<SwitchValueType>, callback: () => any): CaseStatement<ValueType, SwitchValueType>
 
-  case<T = SwitchValueType>(
-    valueOrCondition: ValueType | ConditionCallback<T>,
+  case(
+    valueOrCondition: ValueType | ConditionCallback<SwitchValueType>,
     callback: () => any,
   ) {
     if (typeof valueOrCondition === 'function') {
-      return new CaseStatement<ValueType, T>([
-        ...this.entries as CaseEntry<T, ValueType>[],
+      return new CaseStatement<ValueType, SwitchValueType>([
+        ...this.entries as CaseEntry<SwitchValueType, ValueType>[],
         { type: 'condition', condition: valueOrCondition, callback },
       ])
     }