V6 classify

Test/src/Main/js/Test/Main2.js

@@ -0,0 +1 @@
+module.exports = "a"

Test/src/Main/package.info.json

@@ -1,25 +1,37 @@
 {
-	"Id": "TypeWriterTest",
-	"Name": "TypeWriter Test",
-	"Description": "A Test for TypeWriter",
-	"Version": "1.0.0",
-	"Authors": {
-		"Developers": [
-			"CoreByte"
-		],
-		"Contributors": []
-	},
-	"Contact": {
-		"Website": "",
-		"Source": "",
-		"Socials": {}
-	},
-	"Dependencies": [
-		"npm+node-fetch@3.3.1",
-		"npm+types/node-fetch@2.6.4",
-		"npm+discord.js@14.12.1"
-	],
-	"Entrypoints": {
-		"Main": "Test"
-	}
+    "Id": "TypeWriterTest",
+    "Name": "TypeWriter Test",
+    "Description": "A Test for TypeWriter",
+    "Version": "1.0.0",
+    "Authors": {
+        "Developers": [
+            "CoreByte"
+        ],
+        "Contributors": []
+    },
+    "Contact": {
+        "Website": "",
+        "Source": "",
+        "Socials": {}
+    },
+    "Dependencies": [
+        "npm+discord.js@14.14.1",
+        "npm+argparse@2.0.1",
+        "npm+colors@1.4.0",
+        "npm+extract-zip@2.0.1",
+        "npm+fs-extra@11.1.1",
+        "npm+get-caller-file@2.0.5",
+        "npm+is-builtin-module@3.2.1",
+        "npm+is-online@10.0.0",
+        "npm+klaw-sync@6.0.0",
+        "npm+node-fetch@3.3.2",
+        "npm+randomstring@1.3.0",
+        "npm+require-from-string@2.0.2",
+        "npm+require-main-filename@2.0.0",
+        "npm+sync-fetch@0.5.2",
+        "npm+tar@6.2.0"
+    ],
+    "Entrypoints": {
+        "Main": "Test"
+    }
 }

TypeWriter/Actions/build/Index.js

@@ -1,11 +1,15 @@
-const BuildHelper = require("../../Lib/BuildHelper.js")
+const BuilderClass = require("../../Classes/Builder.js")
 
 module.exports.Name = "Build"
 module.exports.Execute = async function() {
     const InputPath = TypeWriter.Arguments.input
     const InputBranch = TypeWriter.Arguments.branch
+    const OutputPath = TypeWriter.Arguments.output
 
-    const BuildId = BuildHelper.Build(InputPath, InputBranch)
-    BuildHelper.CompressBuild(BuildId, TypeWriter.Arguments.output)
-    BuildHelper.CleanupBuild(BuildId)
+    const Builder = new BuilderClass(InputPath, InputBranch, OutputPath)
+    await Builder.ValidatePackageInfo()
+    await Builder.ScanCode()
+    await Builder.ScanResources()
+    await Builder.Compress()
+    await Builder.Cleanup()
 }

TypeWriter/Actions/execute/Index.js

@@ -1,21 +1,21 @@
 const FS = require("fs-extra")
-const RandomString = require("randomstring")
 const Path = require("path")
 const LoadEnvoirment = require("../../Lib/LoadEnvoirment")
+const RandomString = require("../../Lib/RandomString.js")
+
 
 module.exports.Name = "Execute"
 module.exports.Execute = async function() {
     const InputPath = TypeWriter.Arguments.input
-    const ExecuteId = RandomString.generate(32)
+    const ExecuteId = RandomString(32)
     const ExecuteFolder = Path.normalize(`${TypeWriter.Folder}/Cache/ExecuteCache/${ExecuteId}/`)
+    FS.mkdirSync(ExecuteFolder)
 
     TypeWriter.Logger.Debug(`Input is ${InputPath}`)
     TypeWriter.Logger.Debug(`ExecuteId is ${ExecuteId}`)
     TypeWriter.Logger.Debug(`ExecuteFolder is ${ExecuteFolder}`)
 
-    FS.mkdirSync(ExecuteFolder)
-
     await LoadEnvoirment(ExecuteFolder)
-    const Package = TypeWriter.LoadFile(InputPath)
-    TypeWriter.LoadEntrypointAsync(Package.Id, "Main")
+    const Package = await TypeWriter.PackageManager.LoadPackage(OutputFile)
+    await Package.LoadEntrypoint("Main")
 }

TypeWriter/Actions/run/Index.js

@@ -1,30 +1,30 @@
-const RandomString = require("randomstring")
 const FS = require("fs-extra")
 const Path = require("path")
 
-const BuildHelper = require("../../Lib/BuildHelper.js")
+const BuilderClass = require("../../Classes/Builder.js")
 const LoadEnvoirment = require("../../Lib/LoadEnvoirment")
+const RandomString = require("../../Lib/RandomString.js")
 
 module.exports.Name = "Run"
 module.exports.Execute = async function() {
     const InputPath = TypeWriter.Arguments.input
     const InputBranch = TypeWriter.Arguments.branch
 
-    const BuildId = BuildHelper.Build(InputPath, InputBranch)
-    const ExecuteId = RandomString.generate(32)
+    const ExecuteId = RandomString(32)
+    const ExecuteFolder = Path.normalize(`${TypeWriter.Folders.Cache.ExecuteCacheFolder}/${ExecuteId}/`)
+    FS.mkdirSync(ExecuteFolder)
+
     TypeWriter.Logger.Debug(`ExecuteId is ${ExecuteId}`)
-    const ExecuteFolder = Path.normalize(`${TypeWriter.Folder}/Cache/ExecuteCache/${ExecuteId}/`)
     TypeWriter.Logger.Debug(`ExecuteFolder is ${ExecuteFolder}`)
-
-    FS.mkdirSync(ExecuteFolder)
 
-    BuildHelper.CompressBuild(BuildId, ExecuteFolder)
-    BuildHelper.CleanupBuild(BuildId)
-    if (BuildId == false) {
-        return
-    }
+    const Builder = new BuilderClass(InputPath, InputBranch, ExecuteFolder)
+    await Builder.ValidatePackageInfo()
+    await Builder.ScanCode()
+    await Builder.ScanResources()
+    const OutputFile = await Builder.Compress()
+    await Builder.Cleanup()
 
     await LoadEnvoirment(ExecuteFolder)
-    const Package = TypeWriter.LoadFile(`${ExecuteFolder}/${FS.readdirSync(ExecuteFolder)}`)
-    TypeWriter.LoadEntrypointAsync(Package.Id, "Main")
+    const Package = await TypeWriter.PackageManager.LoadPackage(OutputFile)
+    await Package.LoadEntrypoint("Main")
 }

TypeWriter/Assets/package.info.json

@@ -8,9 +8,7 @@
         "Developers": [
             "CoreByte"
         ],
-        "Contributors": [
-
-        ]
+        "Contributors": []
     },
 
     "Contact": {
@@ -19,14 +17,9 @@
         "Socials": {}
     },
 
-    "Dependencies": [
-        {
-            "Source": "LIT",
-            "Package": "coro-spawn",
-            "Version": null,
-            "Type": "Packaged"
-        }
-    ],
+    "Dependencies": [],
+
+    "Preload": [],
 
     "Entrypoints": {
         "Main": "me.corebyte.test"

TypeWriter/Classes/Builder.js

@@ -0,0 +1,173 @@
+const FS = require("fs-extra")
+const Path = require("path")
+const KlawSync = require('klaw-sync')
+const RandomString = require("../Lib/RandomString.js")
+const DependencyParser = require("../Lib/DependencyParser.js")
+const Tar = require("tar")
+
+async function FixDependencyVersions(Dependencies) {
+    let Updated = false
+    const VersionFixes = []
+
+    let DependencyIndex = -1
+    for (const Dependency of Dependencies) {
+        let ParsedDependency = DependencyParser.Parse(Dependency)
+        DependencyIndex++
+
+        if (ParsedDependency.Version != undefined) { continue }
+
+        Updated = true
+        TypeWriter.Logger.Warning(`No version specified for ${ParsedDependency.FullName}, fixing...`)
+        VersionFixes.push(
+            [
+                DependencyIndex,
+                ParsedDependency,
+                async function (DependencyIndex, ParsedDependency) {
+                    const LatestVersion = await TypeWriter.DependencyManager.GetLatestVersion(ParsedDependency)
+                    ParsedDependency.Version = LatestVersion
+                    Dependencies[DependencyIndex] = DependencyParser.Format(ParsedDependency)
+                }
+            ]
+
+        )
+
+    }
+
+    await Promise.all(VersionFixes.map(D => D[2](D[0], D[1])))
+
+    return [Updated, Dependencies]
+}
+
+async function ScanCode(ScanFolder, Extension) {
+    ScanFolder = Path.normalize(ScanFolder)
+    const ScannedCode = {}
+    const Files = KlawSync(ScanFolder, { nodir: true })
+    for (const File of Files) {
+        const FilePath = File.path
+        const CodePath = FilePath.split(ScanFolder)[1].replaceAll("\\", "/").replaceAll("/", ".").substring(1).split(".").slice(0, -1).join(".")
+
+        ScannedCode[CodePath] = {
+            Type: Extension,
+            Code: encodeURIComponent(FS.readFileSync(FilePath, "utf-8"))
+        }
+
+        if (CodePath.endsWith(".Main")) {
+            ScannedCode[CodePath.substring(0, CodePath.length - 5)] = {
+                Type: "Redirect",
+                Path: CodePath
+            }
+        } else if (CodePath.endsWith(".Index")) {
+            ScannedCode[CodePath.substring(0, CodePath.length - 6)] = {
+                Type: "Redirect",
+                Path: CodePath
+            }
+        }
+    }
+
+    return ScannedCode
+}
+
+class Builder {
+    constructor(Folder, Branch, OutputPath) {
+        this.BuildFolder = Folder
+        this.BranchFolder = Path.normalize(`${Folder}/${Branch}/`)
+        this.OutputPath = OutputPath
+        this.BuildId = RandomString(32)
+        this.BuildFolder = Path.normalize(`${TypeWriter.Folders.Cache.BuildCacheFolder}/${this.BuildId}/`)
+        this.PackageInfoFile = Path.normalize(`${this.BranchFolder}/package.info.json`)
+
+        TypeWriter.Logger.Debug(`Building to ${this.BuildFolder}`)
+
+        FS.ensureDirSync(this.BuildFolder)
+        FS.cpSync(this.BranchFolder + "/package.info.json", this.BuildFolder + "/package.info.json")
+
+        this.CreateRequiredFolders()
+    }
+
+    CreateRequiredFolders() {
+        FS.ensureDirSync(this.BranchFolder + "/js")
+        FS.ensureDirSync(this.BranchFolder + "/lua")
+        FS.ensureDirSync(this.BranchFolder + "/resources")
+    }
+
+    async ValidatePackageInfo() {
+        const PackageInfo = FS.readJsonSync(this.PackageInfoFile)
+        let NeedsUpdate = false
+
+        const [Updated, Dependencies] = await FixDependencyVersions(PackageInfo.Dependencies)
+        NeedsUpdate = Updated || NeedsUpdate
+        PackageInfo.Dependencies = Dependencies
+
+        if (NeedsUpdate) {
+            FS.writeJsonSync(this.PackageInfoFile, PackageInfo, { spaces: 4 })
+            FS.writeJSONSync(this.BuildFolder + "/package.info.json", PackageInfo, { spaces: 4 })
+        }
+    }
+
+    async ScanCode() {
+        const ScannedCode = Object.assign(
+            {},
+            await ScanCode(this.BranchFolder + "/lua", "lua"),
+            await ScanCode(this.BranchFolder + "/js", "js")
+        )
+
+        FS.writeJSONSync(
+            `${this.BuildFolder}/Code.json`,
+            ScannedCode,
+            {
+                spaces: "\t"
+            }
+        )
+    }
+
+    async ScanResources() {
+        const ResourceFolder = Path.normalize(`${this.BranchFolder}/resources`)
+        const DestinationResourceFolder = `${this.BuildFolder}/resources/`
+
+        const ResourceIndex = KlawSync(
+            this.BranchFolder + "/resources",
+            {
+                nodir: true
+            }
+        ).map(
+            (File) => {
+                const FilePath = File.path
+                const ResourceFilePath = Path.normalize(FilePath.split(ResourceFolder)[1]).replaceAll("\\", "/")
+                return ResourceFilePath
+            }
+        )
+
+        FS.copySync(ResourceFolder, DestinationResourceFolder)
+        FS.writeJSONSync(
+            `${this.BuildFolder}/ResourceIndex.json`,
+            ResourceIndex,
+            {
+                spaces: "\t"
+            }
+        )
+    }
+
+    async Compress() {
+        const PackageInfo = FS.readJsonSync(this.PackageInfoFile)
+        const OutputFile = Path.join(this.OutputPath + `/${PackageInfo.Id}.twr`)
+        TypeWriter.Logger.Debug(`Outputting to ${OutputFile} in ${this.BuildFolder}`)
+        Tar.create(
+            {
+                file: OutputFile,
+                cwd: this.BuildFolder,
+                sync: true,
+                noMtime: true,
+                portable: true
+            },
+            FS.readdirSync(this.BuildFolder)
+        )
+
+        return OutputFile
+    }
+
+    async Cleanup() {
+        FS.rmSync(this.BuildFolder, { recursive: true, force: true })
+    }
+}
+
+module.exports = Builder