@minecraft/creator-tools 0.8.0 → 0.9.0

package/NOTICE.md

@@ -4,6 +4,28 @@ Copyright 2024 Mojang AB
 
 This repository incorporates material as listed below or described in the code.
 
+### @lunapaint/tga-codec
+
+Copyright (c) 2022, Daniel Imms (https://github.com/Tyriar)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
 ### waveform-playlist
 
 #### MIT License

package/app/Carto.js

@@ -961,18 +961,30 @@ class Carto {
         }
         return newProjectName;
     }
-    async createNewProject(newProjectName, newProjectPath, focus, includeDefaultItems, projectLanguage) {
+    async createNewProject(newProjectName, newProjectPath, newProjectFolder, newProjectFolderTitle, focus, includeDefaultItems, projectLanguage) {
         await this.load();
         const targetProjectName = await this.getNewProjectName(newProjectName);
-        const projectPrefs = await this.prefsProjectsFolder.createFile(targetProjectName + ".json");
+        let projectPrefs;
+        if (newProjectFolder) {
+            projectPrefs = await newProjectFolder.ensureFileFromRelativePath("/.mct/prefs.mctp.json");
+        }
+        else {
+            projectPrefs = await this.prefsProjectsFolder.createFile(targetProjectName + ".json");
+        }
         const newProject = new Project_1.default(this, targetProjectName, projectPrefs);
-        if (newProjectPath) {
+        if (newProjectPath && !newProjectFolder) {
             newProject.mainDeployFolderPath = newProjectPath;
         }
         if (projectLanguage) {
             newProject.preferredScriptLanguage = projectLanguage;
         }
-        await newProject.ensureProjectFolder();
+        if (newProjectFolder) {
+            newProject.setProjectFolder(newProjectFolder);
+            newProject.projectFolderTitle = newProjectFolderTitle;
+        }
+        else {
+            await newProject.ensureProjectFolder();
+        }
         newProject.focus = focus;
         if (includeDefaultItems) {
             await newProject.ensureDefaultItems();
@@ -1056,7 +1068,7 @@ class Carto {
         const project = this.getProjectByName(desiredProjectName);
         const canonPath = StorageUtilities_1.default.canonicalizePath(messageProjectPath);
         if (project !== undefined) {
-            await project.ensureLoadedFromFile();
+            await project.ensurePreferencesAndFolderLoadedFromFile();
             if (project.mainDeployFolderPath !== undefined) {
                 if (canonPath === StorageUtilities_1.default.canonicalizePath(project.mainDeployFolderPath)) {
                     await project.ensureInflated();
@@ -1104,7 +1116,7 @@ class Carto {
             project = this.getProjectByName(desiredProjectName);
         }
         if (project !== undefined && !openDirect) {
-            await project.ensureLoadedFromFile();
+            await project.ensurePreferencesAndFolderLoadedFromFile();
             if (project.mainDeployFolderPath !== undefined) {
                 if (canonPath === StorageUtilities_1.default.canonicalizePath(project.mainDeployFolderPath)) {
                     await project.ensureInflated();
@@ -1130,7 +1142,7 @@ class Carto {
         // now check all other projects to see if one exists.
         for (let i = 0; i < this.projects.length; i++) {
             project = this.projects[i];
-            await project.ensureLoadedFromFile();
+            await project.ensurePreferencesAndFolderLoadedFromFile();
             if (project.mainDeployFolderPath !== undefined) {
                 if (canonPath === StorageUtilities_1.default.canonicalizePath(project.mainDeployFolderPath)) {
                     await project.ensureInflated();
@@ -1161,7 +1173,7 @@ class Carto {
         await this.load();
         for (let i = 0; i < this.projects.length; i++) {
             const project = this.projects[i];
-            await project.ensureLoadedFromFile();
+            await project.ensurePreferencesAndFolderLoadedFromFile();
             await project.ensureProjectFolder();
             if (project.projectFolder) {
                 const projectTargetFolder = zipRoot.ensureFolder(project.name);

package/app/IProjectItemData.js

@@ -3,7 +3,7 @@
 // Licensed under the MIT License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectItemCreationType = exports.ProjectItemErrorStatus = exports.ProjectItemEditPreference = exports.ProjectItemStorageType = exports.ProjectItemType = exports.ProjectItemCategory = exports.MaxItemTypes = void 0;
-exports.MaxItemTypes = 128;
+exports.MaxItemTypes = 129;
 var ProjectItemCategory;
 (function (ProjectItemCategory) {
     ProjectItemCategory[ProjectItemCategory["assets"] = 0] = "assets";
@@ -14,6 +14,7 @@ var ProjectItemCategory;
     ProjectItemCategory[ProjectItemCategory["meta"] = 5] = "meta";
     ProjectItemCategory[ProjectItemCategory["package"] = 6] = "package";
     ProjectItemCategory[ProjectItemCategory["unknown"] = 7] = "unknown";
+    ProjectItemCategory[ProjectItemCategory["mctools"] = 8] = "mctools";
 })(ProjectItemCategory = exports.ProjectItemCategory || (exports.ProjectItemCategory = {}));
 var ProjectItemType;
 (function (ProjectItemType) {
@@ -69,7 +70,7 @@ var ProjectItemType;
     ProjectItemType[ProjectItemType["materialsResourceJson"] = 49] = "materialsResourceJson";
     ProjectItemType[ProjectItemType["musicDefinitionJson"] = 50] = "musicDefinitionJson";
     ProjectItemType[ProjectItemType["soundDefinitionCatalog"] = 51] = "soundDefinitionCatalog";
-    ProjectItemType[ProjectItemType["blockTypeResourceJson"] = 52] = "blockTypeResourceJson";
+    ProjectItemType[ProjectItemType["blockTypeResourceJsonDoNotUse"] = 52] = "blockTypeResourceJsonDoNotUse";
     ProjectItemType[ProjectItemType["MCAddon"] = 53] = "MCAddon";
     ProjectItemType[ProjectItemType["zip"] = 54] = "zip";
     ProjectItemType[ProjectItemType["MCPack"] = 55] = "MCPack";
@@ -145,6 +146,7 @@ var ProjectItemType;
     ProjectItemType[ProjectItemType["personaPackFolder"] = 126] = "personaPackFolder";
     ProjectItemType[ProjectItemType["blockCulling"] = 127] = "blockCulling";
     ProjectItemType[ProjectItemType["craftingItemCatalog"] = 128] = "craftingItemCatalog";
+    ProjectItemType[ProjectItemType["mcToolsProjectPreferences"] = 129] = "mcToolsProjectPreferences";
 })(ProjectItemType = exports.ProjectItemType || (exports.ProjectItemType = {}));
 var ProjectItemStorageType;
 (function (ProjectItemStorageType) {

package/app/LookupUtilities.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utilities_1 = require("../core/Utilities");
+const Database_1 = require("../minecraft/Database");
+const MinecraftUtilities_1 = require("../minecraft/MinecraftUtilities");
+class LookupUtilities {
+    static async getLookup(lookupId) {
+        switch (lookupId) {
+            case "blockType":
+                return await this.getBlockTypeReferences();
+            case "entityType":
+                return await this.getEntityTypeReferences();
+            case "itemType":
+                return await this.getItemTypeReferences();
+            case "soundDefinition":
+                return await this.getSoundDefinitionReferences();
+            case "terrainTexture":
+                return await this.getTerrainTextureReferences();
+            case "entityTypeEvents":
+                break;
+            case "difficulty":
+                break;
+            case "damageCause":
+                break;
+            case "lootTable":
+                break;
+            case "entityTypePlusVariants":
+                break;
+        }
+        return undefined;
+    }
+    static async getSoundDefinitionReferences() {
+        if (this.soundDefRefs) {
+            return this.soundDefRefs;
+        }
+        const soundData = await Database_1.default.getVanillaSoundDefinitionCatalog();
+        const refs = [];
+        if (soundData) {
+            const soundSets = soundData.getSoundDefinitionSetNameList();
+            if (soundSets) {
+                for (const soundSet of soundSets) {
+                    refs.push({
+                        id: soundSet,
+                        title: Utilities_1.default.humanifyMinecraftName(soundSet),
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        this.soundDefRefs = refs;
+        return this.soundDefRefs;
+    }
+    static async getItemTextureReferences() {
+        if (this.itemTextureRefs) {
+            return this.itemTextureRefs;
+        }
+        const itemData = await Database_1.default.getVanillaItemTexturesCatalog();
+        const refs = [];
+        if (itemData) {
+            const textureRefs = itemData.getTextureReferences();
+            if (textureRefs) {
+                for (const textureRef of textureRefs) {
+                    refs.push({
+                        id: textureRef,
+                        title: Utilities_1.default.humanifyMinecraftName(textureRef),
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        this.itemTextureRefs = refs;
+        return this.itemTextureRefs;
+    }
+    static async getTerrainTextureReferences() {
+        if (this.terrainTextureRefs) {
+            return this.terrainTextureRefs;
+        }
+        const terrainData = await Database_1.default.getVanillaTerrainTexturesCatalog();
+        const refs = [];
+        if (terrainData) {
+            const textureRefs = terrainData.getTextureReferences();
+            if (textureRefs) {
+                for (const textureRef of textureRefs) {
+                    refs.push({
+                        id: textureRef,
+                        title: Utilities_1.default.humanifyMinecraftName(textureRef),
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        this.terrainTextureRefs = refs;
+        return this.terrainTextureRefs;
+    }
+    static async getBlockTypeReferences() {
+        if (this.blockTypeRefs) {
+            return this.blockTypeRefs;
+        }
+        const blockData = await Database_1.default.getBlocksMetadata();
+        const refs = [];
+        if (blockData && blockData.data_items) {
+            for (const dataItem of blockData.data_items) {
+                if (dataItem.name && MinecraftUtilities_1.default.isBedrockItem(dataItem.name)) {
+                    const iconImage = MinecraftUtilities_1.default.getBlockDefaultTexturePath(dataItem.name);
+                    refs.push({
+                        id: dataItem.name,
+                        title: Utilities_1.default.humanifyMinecraftName(dataItem.name),
+                        iconImage: iconImage ? "/res/latest/van/preview/resource_pack/" + iconImage + ".png" : undefined,
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        this.blockTypeRefs = refs;
+        return this.blockTypeRefs;
+    }
+    static async getEntityTypeReferences() {
+        if (this.entityTypeRefs) {
+            return this.entityTypeRefs;
+        }
+        const entitiesData = await Database_1.default.getEntitiesMetadata();
+        const refs = [];
+        if (entitiesData && entitiesData.data_items) {
+            for (const dataItem of entitiesData.data_items) {
+                if (dataItem.name && MinecraftUtilities_1.default.isBedrockItem(dataItem.name)) {
+                    refs.push({
+                        id: dataItem.name,
+                        title: Utilities_1.default.humanifyMinecraftName(dataItem.name),
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        LookupUtilities.entityTypeRefs = refs;
+        return LookupUtilities.entityTypeRefs;
+    }
+    static async getItemTypeReferences() {
+        if (this.itemTypeRefs) {
+            return this.itemTypeRefs;
+        }
+        const itemsData = await Database_1.default.getItemsMetadata();
+        const refs = [];
+        if (itemsData && itemsData.data_items) {
+            for (const dataItem of itemsData.data_items) {
+                if (dataItem.name && MinecraftUtilities_1.default.isBedrockItem(dataItem.name)) {
+                    refs.push({
+                        id: dataItem.name,
+                        title: Utilities_1.default.humanifyMinecraftName(dataItem.name),
+                    });
+                }
+            }
+        }
+        LookupUtilities.sortReferences(refs);
+        LookupUtilities.itemTypeRefs = refs;
+        return LookupUtilities.itemTypeRefs;
+    }
+    static appendReferences(core, references) {
+        if (references === undefined) {
+            return;
+        }
+        for (const ref of references) {
+            let foundRef = false;
+            for (const targetRef of core) {
+                if (targetRef.id === ref.id) {
+                    foundRef = true;
+                }
+            }
+            if (!foundRef) {
+                core.push(ref);
+            }
+        }
+    }
+    static sortReferences(references) {
+        references.sort((a, b) => {
+            if (a.title && b.title) {
+                return a.title.localeCompare(b.title);
+            }
+            if (a.id && b.id) {
+                return a.id.toString().localeCompare(b.id.toString());
+            }
+            return 0;
+        });
+    }
+    static getReferencesFromAnnotatedValues(paths, annotationCategory, description, startsWithFilter) {
+        if (!paths) {
+            return undefined;
+        }
+        let simpleRefs = [];
+        for (let path in paths) {
+            const val = paths[path];
+            if (path && val && (!startsWithFilter || path.startsWith(startsWithFilter))) {
+                if (startsWithFilter) {
+                    path = path.substring(startsWithFilter.length);
+                }
+                for (const annotatedVal of val) {
+                    if (annotatedVal.annotation === annotationCategory) {
+                        simpleRefs.push({
+                            id: path,
+                            title: Utilities_1.default.humanifyMinecraftName(path),
+                            description: description
+                                ? Utilities_1.default.stringFormat(description, Utilities_1.default.humanifyMinecraftName(path))
+                                : undefined,
+                        });
+                        continue;
+                    }
+                }
+            }
+        }
+        if (simpleRefs && simpleRefs.length === 0) {
+            return undefined;
+        }
+        return simpleRefs;
+    }
+}
+exports.default = LookupUtilities;
+LookupUtilities.blockTypeRefs = undefined;
+LookupUtilities.entityTypeRefs = undefined;
+LookupUtilities.itemTypeRefs = undefined;
+LookupUtilities.soundDefRefs = undefined;
+LookupUtilities.terrainTextureRefs = undefined;
+LookupUtilities.itemTextureRefs = undefined;
+
+//# sourceMappingURL=../maps/app/LookupUtilities.js.map