@spyglassmc/java-edition 0.3.2 → 0.3.4

package/lib/json/checker/data/index.d.ts

@@ -1,4 +0,0 @@
-import type { JsonChecker } from '@spyglassmc/json/lib/checker/JsonChecker.js';
-export declare const pack_mcmeta: JsonChecker;
-export declare const Checkers: Map<"function" | "advancement" | "dimension" | "dimension_type" | "item_modifier" | "loot_table" | "predicate" | "recipe" | "structure" | "worldgen/biome" | "worldgen/configured_carver" | "worldgen/configured_feature" | "worldgen/configured_structure_feature" | "worldgen/configured_surface_builder" | "worldgen/density_function" | "worldgen/noise" | "worldgen/noise_settings" | "worldgen/placed_feature" | "worldgen/processor_list" | "worldgen/template_pool" | "tag/function" | "tag/activity" | "tag/attribute" | "tag/block" | "tag/block_entity_type" | "tag/block_predicate_type" | "tag/chunk_status" | "tag/custom_stat" | "tag/enchantment" | "tag/entity_type" | "tag/float_provider_type" | "tag/fluid" | "tag/game_event" | "tag/height_provider_type" | "tag/int_provider_type" | "tag/item" | "tag/loot_condition_type" | "tag/loot_function_type" | "tag/loot_nbt_provider_type" | "tag/loot_number_provider_type" | "tag/loot_pool_entry_type" | "tag/loot_score_provider_type" | "tag/memory_module_type" | "tag/menu" | "tag/mob_effect" | "tag/motive" | "tag/particle_type" | "tag/point_of_interest_type" | "tag/pos_rule_test" | "tag/position_source_type" | "tag/potion" | "tag/recipe_serializer" | "tag/recipe_type" | "tag/rule_test" | "tag/schedule" | "tag/sensor_type" | "tag/sound_event" | "tag/stat_type" | "tag/villager_profession" | "tag/villager_type" | "tag/worldgen/biome_source" | "tag/worldgen/block_placer_type" | "tag/worldgen/block_state_provider_type" | "tag/worldgen/carver" | "tag/worldgen/chunk_generator" | "tag/worldgen/decorator" | "tag/worldgen/feature" | "tag/worldgen/feature_size_type" | "tag/worldgen/foliage_placer_type" | "tag/worldgen/material_condition" | "tag/worldgen/material_rule" | "tag/worldgen/placement_modifier_type" | "tag/worldgen/structure_feature" | "tag/worldgen/structure_piece" | "tag/worldgen/structure_pool_element" | "tag/worldgen/structure_processor" | "tag/worldgen/surface_builder" | "tag/worldgen/tree_decorator_type" | "tag/worldgen/trunk_placer_type" | "tag/worldgen/biome" | "tag/worldgen/configured_carver" | "tag/worldgen/configured_feature" | "tag/worldgen/configured_structure_feature" | "tag/worldgen/configured_surface_builder" | "tag/worldgen/density_function" | "tag/worldgen/noise" | "tag/worldgen/noise_settings" | "tag/worldgen/placed_feature" | "tag/worldgen/processor_list" | "tag/worldgen/template_pool", JsonChecker>;
-//# sourceMappingURL=index.d.ts.map

package/lib/json/checker/data/index.js

@@ -1,40 +0,0 @@
-import { as, int, record } from '@spyglassmc/json/lib/checker/index.js';
-import { advancement } from './advancement.js';
-import { biome, configured_carver, configured_surface_builder, } from './biome.js';
-import { dimension, dimension_type, noise_settings } from './dimension.js';
-import { configured_feature } from './feature.js';
-import { item_modifier_list, loot_table, predicate_list } from './loot_table.js';
-import { recipe } from './recipe.js';
-import { configured_structure_feature, processor_list, template_pool, } from './structure.js';
-import { block_tag, entity_type_tag, fluid_tag, function_tag, game_event_tag, item_tag, } from './tag.js';
-import { text_component } from './text_component.js';
-export const pack_mcmeta = as('pack', record({
-    pack: record({
-        pack_format: int,
-        description: text_component,
-    }),
-}, { allowUnknownProperties: true }));
-export const Checkers = new Map([
-    ['advancement', advancement],
-    ['dimension', dimension],
-    ['dimension_type', dimension_type],
-    ['item_modifier', item_modifier_list],
-    ['loot_table', loot_table],
-    ['predicate', predicate_list],
-    ['recipe', recipe],
-    ['tag/block', block_tag],
-    ['tag/entity_type', entity_type_tag],
-    ['tag/fluid', fluid_tag],
-    ['tag/function', function_tag],
-    ['tag/game_event', game_event_tag],
-    ['tag/item', item_tag],
-    ['worldgen/biome', biome],
-    ['worldgen/configured_carver', configured_carver],
-    ['worldgen/configured_surface_builder', configured_surface_builder],
-    ['worldgen/configured_feature', configured_feature],
-    ['worldgen/configured_structure_feature', configured_structure_feature],
-    ['worldgen/noise_settings', noise_settings],
-    ['worldgen/processor_list', processor_list],
-    ['worldgen/template_pool', template_pool],
-]);
-//# sourceMappingURL=index.js.map

package/lib/json/checker/data/loot_table.d.ts

@@ -1,8 +0,0 @@
-export declare const predicate: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const predicate_list: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const item_modifier: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const item_modifier_list: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const loot_entry: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const loot_pool: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const loot_table: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-//# sourceMappingURL=loot_table.d.ts.map

package/lib/json/checker/data/loot_table.js

@@ -1,275 +0,0 @@
-import { any, as, boolean, dispatch, extract, float, floatRange, int, intRange, listOf, literal, object, opt, pick, record, resource, simpleString, } from '@spyglassmc/json/lib/checker/primitives/index.js';
-import { blockStateList, blockStateMap, nbt, nbtPath, uuid, versioned, } from '../util/index.js';
-import { damage_source_predicate, entity_predicate, item_predicate, location_predicate, } from './advancement.js';
-import { int_bounds, nbt_provider, number_provider, Slots } from './common.js';
-import { text_component } from './text_component.js';
-const loot_context_types = [
-    'empty',
-    'chest',
-    'command',
-    'selector',
-    'fishing',
-    'entity',
-    'gift',
-    'barter',
-    'advancement_reward',
-    'advancement_entity',
-    'generic',
-    'block',
-];
-const map_decorations = [
-    'mansion',
-    'monument',
-    'player',
-    'frame',
-    'red_marker',
-    'blue_marker',
-    'target_x',
-    'target_point',
-    'player_off_map',
-    'player_off_limits',
-    'red_x',
-    'banner_white',
-    'banner_orange',
-    'banner_magenta',
-    'banner_light_blue',
-    'banner_yellow',
-    'banner_lime',
-    'banner_pink',
-    'banner_gray',
-    'banner_light_gray',
-    'banner_cyan',
-    'banner_purple',
-    'banner_blue',
-    'banner_brown',
-    'banner_green',
-    'banner_red',
-    'banner_black',
-];
-export const predicate = as('predicate', dispatch('condition', (condition, props) => record({
-    condition: resource('loot_condition_type'),
-    ...pick(condition, {
-        alternative: {
-            terms: listOf(predicate),
-        },
-        block_state_property: {
-            block: resource('block'),
-            properties: blockStateMap({ id: extract('block', props) }),
-        },
-        damage_source_properties: {
-            predicate: damage_source_predicate,
-        },
-        entity_properties: {
-            entity: literal(['this', 'killer', 'killer_player', 'direct_killer']),
-            predicate: entity_predicate,
-        },
-        entity_scores: {
-            entity: literal(['this', 'killer', 'killer_player', 'direct_killer']),
-            scores: object(literal('objective'), () => int_bounds),
-        },
-        inverted: {
-            term: predicate,
-        },
-        killed_by_player: {
-            inverse: opt(boolean, false),
-        },
-        location_check: {
-            offsetX: opt(int, 0),
-            offsetY: opt(int, 0),
-            offsetZ: opt(int, 0),
-            predicate: location_predicate,
-        },
-        match_tool: {
-            predicate: item_predicate,
-        },
-        random_chance: {
-            chance: floatRange(0, 1),
-        },
-        random_chance_with_looting: {
-            chance: floatRange(0, 1),
-            looting_multiplier: float,
-        },
-        reference: {
-            name: resource('predicate'),
-        },
-        table_bonus: {
-            enchantment: resource('enchantment'),
-            chances: listOf(floatRange(0, 1)),
-        },
-        time_check: {
-            value: int_bounds,
-            period: opt(int),
-        },
-        value_check: {
-            value: number_provider,
-            range: int_bounds,
-        },
-        weather_check: {
-            raining: opt(boolean),
-            thundering: opt(boolean),
-        },
-    }),
-})));
-export const predicate_list = any([predicate, listOf(predicate)]);
-export const item_modifier = as('item_modifier', dispatch('function', (function_, props, ctx) => record({
-    function: resource('loot_function_type'),
-    ...pick(function_, {
-        apply_bonus: {
-            enchantment: resource('enchantment'),
-            formula: resource([
-                'binomial_with_bonus_count',
-                'ore_drops',
-                'uniform_bonus_count',
-            ]),
-            ...pick(extract('formula', props), {
-                binomial_with_bonus_count: {
-                    parameters: record({
-                        extra: float,
-                        probability: floatRange(0, 1),
-                    }),
-                },
-                uniform_bonus_count: {
-                    parameters: record({
-                        bonusMultiplier: float,
-                    }),
-                },
-            }),
-        },
-        copy_name: {
-            source: literal(['this', 'killer', 'killer_player', 'block_entity']),
-        },
-        copy_nbt: {
-            source: nbt_provider,
-            ops: listOf(record({
-                source: nbtPath({ registry: 'entity_type' }),
-                target: nbtPath({ registry: 'item' }),
-                op: literal(['replace', 'append', 'merge']),
-            })),
-        },
-        copy_state: {
-            block: resource('block'),
-            properties: blockStateList({ id: extract('block', props) }),
-        },
-        enchant_randomly: {
-            enchantments: opt(listOf(resource('enchantment'))),
-        },
-        enchant_with_levels: {
-            levels: number_provider,
-            treasure: opt(boolean, false),
-        },
-        exploration_map: {
-            destination: opt(resource('worldgen/structure_feature'), 'buried_treasure'),
-            decoration: opt(literal(map_decorations), 'mansion'),
-            zoom: opt(int, 2),
-            search_radius: opt(int, 50),
-            skip_existing_chunks: opt(boolean, true),
-        },
-        fill_player_head: {
-            entity: literal(['this', 'killer', 'killer_player', 'direct_killer']),
-        },
-        limit_count: {
-            limit: int_bounds,
-        },
-        looting_enchant: {
-            count: number_provider,
-            limit: opt(int, 0),
-        },
-        set_attributes: {
-            modifiers: listOf(record({
-                attribute: resource('attribute'),
-                name: simpleString,
-                operation: literal([
-                    'addition',
-                    'multiply_base',
-                    'multiply_total',
-                ]),
-                id: opt(uuid),
-                amount: number_provider,
-                slot: any([literal(Slots), listOf(literal(Slots))]),
-            })),
-        },
-        set_contents: {
-            type: versioned(ctx, '1.18', resource('block_entity_type')),
-            entries: listOf(loot_entry),
-        },
-        set_count: {
-            count: number_provider,
-            add: opt(versioned(ctx, '1.17', boolean), false),
-        },
-        set_damage: {
-            damage: number_provider,
-            add: opt(versioned(ctx, '1.17', boolean), false),
-        },
-        set_loot_table: {
-            name: resource('loot_table'),
-            seed: opt(int, 0),
-        },
-        set_lore: {
-            entity: opt(literal(['this', 'killer', 'killer_player', 'direct_killer'])),
-            lore: listOf(text_component),
-            replace: opt(boolean, false),
-        },
-        set_name: {
-            entity: opt(literal(['this', 'killer', 'killer_player', 'direct_killer'])),
-            name: opt(text_component),
-        },
-        set_nbt: {
-            tag: nbt({ registry: 'item' }),
-        },
-        set_potion: {
-            id: resource('potion'),
-        },
-        set_stew_effect: {
-            effects: opt(listOf(record({
-                type: resource('mob_effect'),
-                duration: number_provider,
-            })), []),
-        },
-    }),
-    conditions: opt(listOf(predicate)),
-})));
-export const item_modifier_list = any([item_modifier, listOf(item_modifier)]);
-export const loot_entry = as('loot_entry', dispatch('type', (type) => record({
-    type: resource('loot_pool_entry_type'),
-    weight: opt(intRange(1, undefined), 1),
-    quality: opt(int, 0),
-    ...pick(type, {
-        alternatives: {
-            children: listOf(loot_entry),
-        },
-        dynamic: {
-            name: resource(['contents']),
-        },
-        group: {
-            children: listOf(loot_entry),
-        },
-        item: {
-            name: resource('item'),
-        },
-        loot_table: {
-            name: resource('loot_table'),
-        },
-        sequence: {
-            children: listOf(loot_entry),
-        },
-        tag: {
-            name: resource('tag/item'),
-            expand: boolean,
-        },
-    }),
-    functions: opt(listOf(item_modifier), []),
-    conditions: opt(listOf(predicate), []),
-})));
-export const loot_pool = as('loot_pool', record({
-    rolls: number_provider,
-    bonus_rolls: opt(number_provider, 0),
-    entries: listOf(loot_entry),
-    functions: opt(listOf(item_modifier), []),
-    conditions: opt(listOf(predicate), []),
-}));
-export const loot_table = as('loot_table', record({
-    type: opt(resource(loot_context_types)),
-    pools: opt(listOf(loot_pool), []),
-    functions: opt(listOf(item_modifier), []),
-}));
-//# sourceMappingURL=loot_table.js.map

package/lib/json/checker/data/recipe.d.ts

@@ -1,2 +0,0 @@
-export declare const recipe: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-//# sourceMappingURL=recipe.d.ts.map

package/lib/json/checker/data/recipe.js

@@ -1,50 +0,0 @@
-import { any, as, dispatch, float, int, intRange, listOf, object, opt, pick, record, resource, simpleString, when, } from '@spyglassmc/json/lib/checker/primitives/index.js';
-import { patternKeys, recipeGroup } from '../util/index.js';
-const one_recipe_ingredient = any([
-    record({
-        item: resource('item'),
-    }),
-    record({
-        tag: resource('tag/item'),
-    }),
-]);
-const recipe_ingredient = any([
-    one_recipe_ingredient,
-    listOf(one_recipe_ingredient),
-]);
-const recipe_result = record({
-    item: resource('item'),
-    count: opt(intRange(1, 64), 1),
-});
-export const recipe = as('recipe', dispatch('type', (type, props) => record({
-    type: resource('recipe_serializer'),
-    group: opt(recipeGroup),
-    ...pick(type, {
-        crafting_shaped: {
-            pattern: listOf(simpleString),
-            key: object(patternKeys(props), () => recipe_ingredient),
-            result: recipe_result,
-        },
-        crafting_shapeless: {
-            ingredients: listOf(recipe_ingredient),
-            result: recipe_result,
-        },
-        stonecutting: {
-            ingredient: recipe_ingredient,
-            result: resource('item'),
-            count: int,
-        },
-        smithing: {
-            base: one_recipe_ingredient,
-            addition: one_recipe_ingredient,
-            result: recipe_result,
-        },
-    }),
-    ...when(type, ['blasting', 'campfire_cooking', 'smelting', 'smoking'], {
-        ingredient: recipe_ingredient,
-        result: resource('item'),
-        experience: opt(float, 0),
-        cookingtime: opt(int, type === 'smelting' ? 200 : 100),
-    }),
-})));
-//# sourceMappingURL=recipe.js.map

package/lib/json/checker/data/structure.d.ts

@@ -1,8 +0,0 @@
-export declare const rule_test: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const pos_rule_test: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const processor_list: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const processor_list_ref: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const template_pool: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const template_pool_ref: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const configured_structure_feature: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-//# sourceMappingURL=structure.d.ts.map

package/lib/json/checker/data/structure.js

@@ -1,153 +0,0 @@
-import { any, as, boolean, dispatch, extractNested, float, floatRange, intRange, listOf, literal, opt, pick, record, resource, simpleString, when, } from '@spyglassmc/json/lib/checker/index.js';
-import { nbt, versioned } from '../util/index.js';
-import { block_state, HeightmapType, height_provider } from './common.js';
-import { configured_feature_ref, placed_feature_ref } from './feature.js';
-export const rule_test = as('rule_test', dispatch('predicate_type', (type) => record({
-    predicate_type: resource('rule_test'),
-    ...pick(type, {
-        block_match: {
-            block: resource('block'),
-        },
-        blockstate_match: {
-            block_state: block_state,
-        },
-        random_block_match: {
-            block: resource('block'),
-            probability: floatRange(0, 1),
-        },
-        random_blockstate_match: {
-            block_state: block_state,
-            probability: floatRange(0, 1),
-        },
-        tag_match: {
-            tag: resource('tag/block'),
-        },
-    }),
-})));
-export const pos_rule_test = as('pos_rule_test', dispatch('predicate_type', (type) => record({
-    predicate_type: resource('pos_rule_test'),
-    ...pick(type, {
-        axis_aligned_linear_pos: {
-            axis: literal(['x', 'y', 'z']),
-            min_dist: opt(intRange(0, 255)),
-            max_dist: opt(intRange(0, 255)),
-            min_chance: opt(floatRange(0, 1)),
-            max_chance: opt(floatRange(0, 1)),
-        },
-    }),
-    ...when(type, ['axis_aligned_linear_pos', 'linear_pos'], {}),
-})));
-const processor_rule = as('processor_rule', dispatch((props) => record({
-    position_predicate: opt(pos_rule_test, { predicate_type: 'always_true' }),
-    input_predicate: rule_test,
-    location_predicate: rule_test,
-    output_state: block_state,
-    output_nbt: opt(nbt({
-        registry: 'block',
-        id: extractNested('output_state', 'Name', props),
-    })),
-})));
-const processor = as('processor', dispatch('processor_type', (type) => record({
-    processor_type: resource('worldgen/structure_processor'),
-    ...pick(type, {
-        block_age: {
-            mossiness: float,
-        },
-        block_ignore: {
-            blocks: listOf(block_state),
-        },
-        block_rot: {
-            integrity: floatRange(0, 1),
-        },
-        gravity: {
-            heightmap: literal(HeightmapType),
-        },
-        protected_blocks: {
-            value: resource('tag/block'),
-        },
-        rule: {
-            rules: listOf(processor_rule),
-        },
-    }),
-})));
-export const processor_list = as('processor_list', any([
-    record({
-        processors: listOf(processor),
-    }),
-    listOf(processor),
-]));
-export const processor_list_ref = as('processor_list', any([resource('worldgen/processor_list'), processor_list]));
-const template_element = as('template_element', dispatch('element_type', (type, _, ctx) => record({
-    element_type: resource('worldgen/structure_pool_element'),
-    ...when(type, ['empty_pool_element'], {}, {
-        projection: literal(['rigid', 'terrain_matching']),
-    }),
-    ...pick(type, {
-        feature_pool_element: {
-            feature: versioned(ctx, configured_feature_ref, '1.18', placed_feature_ref),
-        },
-        legacy_single_pool_element: {
-            location: resource('structure'),
-            processors: processor_list_ref,
-        },
-        list_pool_element: {
-            elements: listOf(template_element),
-        },
-        single_pool_element: {
-            location: resource('structure'),
-            processors: processor_list_ref,
-        },
-    }),
-})));
-export const template_pool = as('template_pool', record({
-    name: simpleString,
-    fallback: resource('worldgen/template_pool'),
-    elements: listOf(record({
-        weight: intRange(1, undefined),
-        element: template_element,
-    })),
-}));
-export const template_pool_ref = any([
-    resource('worldgen/template_pool'),
-    template_pool,
-]);
-export const configured_structure_feature = as('structure_feature', dispatch('type', (type) => record({
-    type: resource('worldgen/structure_feature'),
-    config: record({
-        ...when(type, ['bastion_remnant', 'pillager_outpost', 'village'], {
-            start_pool: template_pool_ref,
-            size: intRange(0, 7),
-        }, pick(type, {
-            buried_treasure: {
-                probability: floatRange(0, 1),
-            },
-            mineshaft: {
-                type: literal(['normal', 'mesa']),
-                probability: floatRange(0, 1),
-            },
-            nether_fossil: {
-                height: height_provider,
-            },
-            ocean_ruin: {
-                biome_temp: literal(['cold', 'warm']),
-                large_probability: floatRange(0, 1),
-                cluster_probability: floatRange(0, 1),
-            },
-            ruined_portal: {
-                portal_type: literal([
-                    'standard',
-                    'desert',
-                    'jungle',
-                    'mountain',
-                    'nether',
-                    'ocean',
-                    'swamp',
-                ]),
-            },
-            shipwreck: {
-                is_beached: opt(boolean, false),
-            },
-        })),
-    }),
-})));
-//# sourceMappingURL=structure.js.map

package/lib/json/checker/data/tag.d.ts

@@ -1,7 +0,0 @@
-export declare const block_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const entity_type_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const fluid_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const function_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const game_event_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-export declare const item_tag: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-//# sourceMappingURL=tag.d.ts.map

package/lib/json/checker/data/tag.js

@@ -1,35 +0,0 @@
-import { ResourceLocation } from '@spyglassmc/core';
-import { JsonObjectNode, JsonStringNode } from '@spyglassmc/json';
-import { any, boolean, opt, record, resource, uniqueListOf, } from '@spyglassmc/json/lib/checker/primitives/index.js';
-import { localize } from '@spyglassmc/locales';
-const tag = (type) => record({
-    replace: opt(boolean, false),
-    values: uniqueListOf(any([
-        resource(type, true),
-        record({
-            id: resource(type, true),
-            required: opt(boolean, true),
-        }),
-    ]), {
-        items: (node) => {
-            if (JsonStringNode.is(node)) {
-                return [ResourceLocation.shorten(node.value), node];
-            }
-            if (JsonObjectNode.is(node)) {
-                const id = node.children.find((c) => c.key?.value === 'id');
-                if (id && id.value && JsonStringNode.is(id.value)) {
-                    return [ResourceLocation.shorten(id.value.value), id.value];
-                }
-            }
-            return [undefined, node];
-        },
-        report: (node, ctx) => ctx.err.report(localize('json.checker.tag-entry.duplicate'), node, 2 /* ErrorSeverity.Warning */),
-    }),
-});
-export const block_tag = tag('block');
-export const entity_type_tag = tag('entity_type');
-export const fluid_tag = tag('fluid');
-export const function_tag = tag('function');
-export const game_event_tag = tag('game_event');
-export const item_tag = tag('item');
-//# sourceMappingURL=tag.js.map

package/lib/json/checker/data/text_component.d.ts

@@ -1,2 +0,0 @@
-export declare const text_component: import("@spyglassmc/json/lib/checker/JsonChecker.js").JsonChecker;
-//# sourceMappingURL=text_component.d.ts.map