sandstone 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/core/resources/datapack/mcfunction.d.ts

@@ -62,7 +62,7 @@ export declare class MCFunctionNode extends ContainerNode implements ResourceNod
      */
     exitContext: () => ContainerNode | ContainerCommandNode<unknown[]> | undefined;
     getValue: () => string;
-    [util.inspect.custom](depth: number, options: any): string;
+    [util.inspect.custom](_depth: number, options: any): string;
 }
 export type MCFunctionClassArguments = {
     /**

package/dist/core/resources/datapack/variant.d.ts

@@ -1,4 +1,4 @@
-import type { SymbolResource } from "../../../arguments/index.js";
+import { type SymbolResource } from "../../../arguments/index.js";
 import { ContainerNode } from "../../nodes.js";
 import type { SandstoneCore } from "../../sandstoneCore.js";
 import type { ResourceClassArguments, ResourceNode } from "../resource.js";

package/dist/core/resources/resource.d.ts

@@ -1,10 +1,11 @@
 import type fs from 'fs-extra';
 import type { SandstoneCommands } from "../../commands/commands.js";
-import type { Node, SandstoneCore } from "../../core/index.js";
+import { type Node, type SandstoneCore } from "../../core/index.js";
 import type { ResourcePath, SandstonePack } from "../../pack/index.js";
 import type { PackType } from "../../pack/packType.js";
 import type { BASIC_CONFLICT_STRATEGIES, LiteralUnion, MakeInstanceCallable } from "../../utils.js";
 import type { NBTSerializable } from "../../arguments/nbt.js";
+import { RESOURCE_PATHS } from "../../arguments/index.js";
 export type ResourceClassArguments<ConflictType extends 'default' | 'list' | 'function'> = {
     /**
      * Whether the associated Node should be added to Sandstone Core.
@@ -36,7 +37,7 @@ export type ResourceNode<T = ResourceClass<any>> = Node & {
 export type ResourceNodeConstructor<N extends Node> = new (sandstoneCore: SandstoneCore, resource: any) => N;
 export declare abstract class ResourceClass<N extends ResourceNode = ResourceNode<any>> implements NBTSerializable {
     protected core: SandstoneCore;
-    protected _resourceType: string;
+    readonly _resourceType: string;
     node: N;
     packType: PackType;
     fileExtension: string;
@@ -59,7 +60,6 @@ export declare abstract class ResourceClass<N extends ResourceNode = ResourceNod
     get namespace(): string;
     generate: () => void;
     toString(): string;
-    toNBT(): string;
 }
 export declare abstract class CallableResourceClass<N extends ResourceNode = ResourceNode<any>> extends ResourceClass<N> {
     private _that;
@@ -91,4 +91,4 @@ export declare class ResourceNodesMap<T extends ResourceNode = ResourceNode> {
      */
     get(node: T): T | undefined;
 }
-export declare function jsonStringify(json: any): string;
+export declare function jsonStringify(json: any, resourceType: keyof typeof RESOURCE_PATHS): string;

package/dist/flow/Flow.d.ts

@@ -1,6 +1,6 @@
 import type { Registry, ContainerSlotSelector, Coordinates, EntitySlotSelector, JSONTextComponent, MultipleEntitiesArgument, MultiplePlayersArgument, NBTObject, SymbolBlock, SymbolMcdocBlockStates } from "../arguments/index.js";
 import type { BlockEntity, BlockStatic, ParseBlockState } from "../commands/implementations/block/setblock.js";
-import type { ConditionClass, DataArray, DataArrayInitial, DataIndexMap, DataIndexMapInitial, DataPointClass, IterableDataClass, StringDataPointClass } from "../variables/index.js";
+import type { ConditionClass, DataPointClass, IterableDataClass, JSONTextComponentClass, StringDataPointClass } from "../variables/index.js";
 import { Score } from "../variables/index.js";
 import type { DataPointPickClass, MCFunctionClass, PredicateClass, SandstoneCore } from "../core/index.js";
 import type { LiteralUnion } from "../utils.js";
@@ -8,13 +8,13 @@ import { AndNode, ConditionNode, NotNode, OrNode, type BlockConditionNode, type
 import type { ItemPredicate } from "./conditions/variables/items.js";
 import { IfStatement } from "./if_else.js";
 import { ForIStatement, ForOfStatement, WhileStatement } from "./loops/index.js";
-import type { DefaultType } from "./switch_case.js";
+import type { ConditionCallback, DefaultType, SwitchCase } from "./switch_case.js";
 import { CaseStatement } from "./switch_case.js";
 export type Condition = ConditionNode | ConditionClass;
+export declare function conditionToNode(condition: Condition): ConditionNode;
 export declare class Flow {
     sandstoneCore: SandstoneCore;
     constructor(sandstoneCore: SandstoneCore);
-    conditionToNode(condition: Condition): ConditionNode;
     if: (condition: Condition, callback: () => void) => IfStatement;
     and: (...conditions: Condition[]) => AndNode;
     or: (...conditions: Condition[]) => OrNode;
@@ -39,9 +39,9 @@ export declare class Flow {
      * @param broadcast Whether to scope the broadcast of the error (from `@a`) or disable it.
      * @param dataPoint Disable storing to data point.
      *
-     * @returns The full error text component string.
+     * @returns The full error text component.
      */
-    throw(error: JSONTextComponent | undefined, broadcast: MultiplePlayersArgument<false> | false | undefined, dataPoint: false): string;
+    throw(error: JSONTextComponent | undefined, broadcast: MultiplePlayersArgument<false> | false | undefined, dataPoint: false): JSONTextComponentClass;
     /**
      * Logs an error in data storage and chat by default and `return fail`'s from the context.
      *
@@ -59,18 +59,13 @@ export declare class Flow {
         start: number | Score,
         end: number | Score
     ], type: 'iterate', callback: (iterator: Score, _continue: () => void) => any): ForIStatement;
-    for(range: [
-        start: number | Score,
-        end: number | Score,
-        maximum?: number
-    ], type: 'binary', callback: (num: number) => any): void;
-    for(type: 'entry', _: 'of', iterable: IterableDataClass, callback: (entry: DataPointClass) => any): ForOfStatement<'entry', [
+    for(type: 'entry', _: 'of' | 'of-reverse', iterable: IterableDataClass<'list' | 'map'>, callback: (entry: DataPointClass) => any): ForOfStatement<'entry', [
         entry: DataPointClass
     ]>;
     for(type: [
         'key',
         'value'
-    ], _: 'of', iterable: DataIndexMap<DataIndexMapInitial>, callback: (key: StringDataPointClass, value: DataPointClass) => any): ForOfStatement<[
+    ], _: 'of' | 'of-reverse', iterable: IterableDataClass<'map'>, callback: (key: StringDataPointClass, value: DataPointClass) => any): ForOfStatement<[
         'key',
         'value'
     ], [
@@ -80,23 +75,27 @@ export declare class Flow {
     for(type: [
         'i',
         'entry'
-    ], _: 'of', iterable: DataArray<DataArrayInitial>, callback: (i: Score, entry: DataPointClass) => any): ForOfStatement<[
+    ], _: 'of' | 'of-reverse', iterable: IterableDataClass<'list' | 'map'>, callback: (i: Score, entry: DataPointClass) => any): ForOfStatement<[
         'i',
         'entry'
     ], [
         i: Score,
         entry: DataPointClass
     ]>;
-    switch<ValueType extends DataPointClass | DataPointPickClass | Score, CheckType extends ValueType extends Score ? number : NBTObject>(value: ValueType, cases: CaseStatement<CheckType> | DefaultType<CheckType>): void;
-    switch<ValueType extends DataPointClass | DataPointPickClass | Score, CheckType extends ValueType extends Score ? number : NBTObject>(value: ValueType, cases: [
-        'case',
-        CheckType,
-        () => any
-    ][], _default?: [
-        'default',
-        () => any
+    switch<ValueType extends DataPointClass | DataPointPickClass | Score, CheckType extends ValueType extends Score ? number : NBTObject>(value: ValueType, cases: CaseStatement<CheckType, ValueType> | DefaultType<CheckType, ValueType>): void;
+    switch<ValueType extends DataPointClass | DataPointPickClass | Score, CheckType extends ValueType extends Score ? number : NBTObject>(value: ValueType, cases: SwitchCase<ValueType, CheckType>[] | [
+        ...SwitchCase<ValueType, CheckType>[],
+        [
+            'default',
+            () => any
+        ]
     ]): void;
-    case<ValueType extends number | NBTObject>(value: ValueType, callback: () => any): CaseStatement<ValueType>;
+    /** 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>;
     /**
      * Checks for a specific biome in a given position.
      * @param coordinates Position to test.

package/dist/flow/if_else.d.ts

@@ -1,14 +1,19 @@
 import * as util from 'util';
-import type { SandstoneCore } from "../core/index.js";
+import type { MCFunctionNode, SandstoneCore } from "../core/index.js";
 import { ContainerNode } from "../core/index.js";
 import type { ConditionNode } from "./conditions/index.js";
-import type { Condition } from "./Flow.js";
+import { type Condition } from "./Flow.js";
 export declare class IfNode extends ContainerNode {
     condition: ConditionNode;
     callback?: (() => void) | undefined;
     nextFlowNode?: IfNode | ElseNode;
     _isElseIf: boolean;
-    constructor(sandstoneCore: SandstoneCore, condition: ConditionNode, callback?: (() => void) | undefined);
+    parentMCFunction: MCFunctionNode;
+    /** Optional callback name override (e.g., 'loop' for loop transformations) */
+    givenCallbackName?: string;
+    /** Set by IfElseTransformationVisitor to the resulting ExecuteCommandNode */
+    resultingExecuteNode?: import("../commands/index.js").ExecuteCommandNode;
+    constructor(sandstoneCore: SandstoneCore, condition: ConditionNode, callback?: (() => void) | undefined, parentMCFunction?: MCFunctionNode);
     getValue: () => never;
     [util.inspect.custom](depth: number, options: any): string;
 }

package/dist/flow/index.d.ts

@@ -2,3 +2,4 @@ export * from "./conditions/index.js";
 export * from "./Flow.js";
 export * from "./if_else.js";
 export * from "./loop.js";
+export * from "./switch_case.js";