warscript 0.0.1-dev.008d8ef

package/objutil/upgrade.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import { LevelFieldValueProvider, ObjectDefinition } from "./object";
+export declare class UpgradeDefinition extends ObjectDefinition {
+    readonly id: string;
+    constructor(baseId: string, id?: string);
+    get name(): string[];
+    set name(v: LevelFieldValueProvider<string>);
+    get tooltip(): string[];
+    set tooltip(v: LevelFieldValueProvider<string>);
+    get tooltipExtended(): string[];
+    set tooltipExtended(v: LevelFieldValueProvider<string>);
+    get hotkey(): string[];
+    set hotkey(v: LevelFieldValueProvider<string>);
+    get buttonPositionX(): 0 | 1 | 2 | 3;
+    set buttonPositionX(v: 0 | 1 | 2 | 3);
+    get buttonPositionY(): 0 | 1 | 2;
+    set buttonPositionY(v: 0 | 1 | 2);
+    get levels(): number;
+    set levels(v: number);
+    get icon(): string[];
+    set icon(v: LevelFieldValueProvider<string>);
+}

package/objutil/upgrade.lua

@@ -0,0 +1,127 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____object = require("objutil.object")
+local ObjectDefinition = ____object.ObjectDefinition
+local idgen = require("objutil.idgen")
+____exports.UpgradeDefinition = __TS__Class()
+local UpgradeDefinition = ____exports.UpgradeDefinition
+UpgradeDefinition.name = "UpgradeDefinition"
+__TS__ClassExtends(UpgradeDefinition, ObjectDefinition)
+function UpgradeDefinition.prototype.____constructor(self, baseId, id)
+    ObjectDefinition.prototype.____constructor(
+        self,
+        currentMap.objects.upgrade:newObject(
+            id or idgen.upgrade(),
+            baseId
+        )
+    )
+    self.id = self.object.id
+end
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "name",
+    {
+        get = function(self)
+            return self:getStringLevelField("gnam")
+        end,
+        set = function(self, v)
+            self:setStringLevelField("gnam", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "tooltip",
+    {
+        get = function(self)
+            return self:getStringLevelField("gtp1")
+        end,
+        set = function(self, v)
+            self:setStringLevelField("gtp1", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "tooltipExtended",
+    {
+        get = function(self)
+            return self:getStringLevelField("gub1")
+        end,
+        set = function(self, v)
+            self:setStringLevelField("gub1", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "hotkey",
+    {
+        get = function(self)
+            return self:getStringLevelField("ghk1")
+        end,
+        set = function(self, v)
+            self:setStringLevelField("ghk1", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "buttonPositionX",
+    {
+        get = function(self)
+            return self:getNumberField("gbpx")
+        end,
+        set = function(self, v)
+            self:setNumberField("gbpx", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "buttonPositionY",
+    {
+        get = function(self)
+            return self:getNumberField("gbpy")
+        end,
+        set = function(self, v)
+            self:setNumberField("gbpy", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "levels",
+    {
+        get = function(self)
+            return self:getNumberField("glvl")
+        end,
+        set = function(self, v)
+            self:setNumberField("glvl", v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UpgradeDefinition.prototype,
+    "icon",
+    {
+        get = function(self)
+            return self:getStringLevelField("gar1")
+        end,
+        set = function(self, v)
+            self:setStringLevelField("gar1", v)
+        end
+    },
+    true
+)
+return ____exports

package/operation.d.ts

@@ -0,0 +1,35 @@
+/** @noSelfInFile */
+import { Event } from "./event";
+declare global {
+    type PromiseExecutor<T> = ConstructorParameters<typeof Promise<T>>[0];
+    type PromiseResolve<T> = Parameters<PromiseExecutor<T>>[0];
+    type PromiseReject = Parameters<PromiseExecutor<unknown>>[1];
+}
+export declare class OperationMonitor<T> extends Promise<T> {
+    private readonly o;
+    constructor(operation: Operation<T>, ...args: ConstructorParameters<typeof Promise<T>>);
+    cancel(): boolean;
+}
+declare const OperationContinue: unique symbol;
+type OperationContinue = typeof OperationContinue;
+export { OperationContinue };
+export declare abstract class Operation<T> {
+    protected constructor();
+    private started;
+    protected progress: number;
+    protected maximum: number;
+    isCanceled: boolean;
+    get isStarted(): boolean;
+    execute(): OperationMonitor<T>;
+    protected abstract estimate(): number | Promise<number>;
+    protected abstract work(): T | OperationContinue | Promise<T | OperationContinue>;
+    get onSuccess(): Event<[operation: Operation<T>, result: T]>;
+    get onFailure(): Event<[operation: Operation<T>, reason?: any]>;
+    get onComplete(): Event<[
+        operation: Operation<T>,
+        ...result: [success: true, result: T] | [success: false, reason?: any]
+    ]>;
+    get onProgress(): Event<[operation: Operation<T>]>;
+    protected abstract doCancel(): boolean;
+    cancel(): boolean;
+}

package/operation.lua

@@ -0,0 +1,179 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__Promise = ____lualib.__TS__Promise
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Symbol = ____lualib.__TS__Symbol
+local Symbol = ____lualib.Symbol
+local __TS__New = ____lualib.__TS__New
+local __TS__AsyncAwaiter = ____lualib.__TS__AsyncAwaiter
+local __TS__Await = ____lualib.__TS__Await
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+local ____exception = require("exception")
+local CancellationException = ____exception.CancellationException
+local IllegalStateException = ____exception.IllegalStateException
+local ____rawget = _G.rawget
+local rawset = _G.rawset
+____exports.OperationMonitor = __TS__Class()
+local OperationMonitor = ____exports.OperationMonitor
+OperationMonitor.name = "OperationMonitor"
+__TS__ClassExtends(OperationMonitor, __TS__Promise)
+function OperationMonitor.prototype.____constructor(self, operation, ...)
+    local args = {...}
+    __TS__Promise.prototype.____constructor(
+        self,
+        table.unpack(args)
+    )
+    self.o = operation
+end
+function OperationMonitor.prototype.cancel(self)
+    return self.o:cancel()
+end
+local OperationContinue = __TS__Symbol()
+____exports.OperationContinue = OperationContinue
+____exports.Operation = __TS__Class()
+local Operation = ____exports.Operation
+Operation.name = "Operation"
+function Operation.prototype.____constructor(self)
+    self.started = false
+    self.progress = 0
+    self.maximum = 0
+    self.isCanceled = false
+end
+function Operation.prototype.execute(self)
+    if self.started then
+        error(
+            __TS__New(IllegalStateException, "Operation already started"),
+            0
+        )
+    end
+    self.started = true
+    return __TS__New(
+        ____exports.OperationMonitor,
+        self,
+        function(____, resolve, reject)
+            return __TS__AsyncAwaiter(function(____awaiter_resolve)
+                local result
+                local progress = self.progress
+                local ____try = __TS__AsyncAwaiter(function()
+                    local maximum = __TS__Await(self:estimate())
+                    self.maximum = maximum
+                    if maximum ~= 0 then
+                        local onProgress = ____rawget(self, "onProgress")
+                        if onProgress ~= nil then
+                            Event.invoke(onProgress, self)
+                        end
+                    end
+                    repeat
+                        do
+                            if self.isCanceled then
+                                local reason = __TS__New(CancellationException)
+                                reject(nil, reason)
+                                local onFailure = ____rawget(self, "onFailure")
+                                if onFailure ~= nil then
+                                    Event.invoke(onFailure, self, reason)
+                                end
+                                local onComplete = ____rawget(self, "onComplete")
+                                if onComplete ~= nil then
+                                    Event.invoke(onComplete, self, false, reason)
+                                end
+                                return ____awaiter_resolve(nil)
+                            end
+                            result = __TS__Await(self:work())
+                            if self.progress ~= progress or self.maximum ~= maximum then
+                                progress = self.progress
+                                maximum = self.maximum
+                                local onProgress = ____rawget(self, "onProgress")
+                                if onProgress ~= nil then
+                                    Event.invoke(onProgress, self)
+                                end
+                            end
+                        end
+                    until not (result == OperationContinue)
+                end)
+                __TS__Await(____try.catch(
+                    ____try,
+                    function(____, reason)
+                        reject(nil, reason)
+                        local onFailure = ____rawget(self, "onFailure")
+                        if onFailure ~= nil then
+                            Event.invoke(onFailure, self, reason)
+                        end
+                        local onComplete = ____rawget(self, "onComplete")
+                        if onComplete ~= nil then
+                            Event.invoke(onComplete, self, false, reason)
+                        end
+                        return ____awaiter_resolve(nil)
+                    end
+                ))
+                resolve(nil, result)
+                local onSuccess = ____rawget(self, "onSuccess")
+                if onSuccess ~= nil then
+                    Event.invoke(onSuccess, self, result)
+                end
+                local onComplete = ____rawget(self, "onComplete")
+                if onComplete ~= nil then
+                    Event.invoke(onComplete, self, true, result)
+                end
+            end)
+        end
+    )
+end
+function Operation.prototype.cancel(self)
+    if self:doCancel() then
+        self.isCanceled = true
+        return true
+    end
+    return false
+end
+__TS__SetDescriptor(
+    Operation.prototype,
+    "isStarted",
+    {get = function(self)
+        return self.started
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Operation.prototype,
+    "onSuccess",
+    {get = function(self)
+        local onSuccess = __TS__New(Event)
+        rawset(self, "onSuccess", onSuccess)
+        return onSuccess
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Operation.prototype,
+    "onFailure",
+    {get = function(self)
+        local onFailure = __TS__New(Event)
+        rawset(self, "onFailure", onFailure)
+        return onFailure
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Operation.prototype,
+    "onComplete",
+    {get = function(self)
+        local onComplete = __TS__New(Event)
+        rawset(self, "onComplete", onComplete)
+        return onComplete
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Operation.prototype,
+    "onProgress",
+    {get = function(self)
+        local onProgress = __TS__New(Event)
+        rawset(self, "onProgress", onProgress)
+        return onProgress
+    end},
+    true
+)
+return ____exports

package/package.json

@@ -0,0 +1,46 @@
+{
+    "$schema": "https://json.schemastore.org/package",
+    "name": "warscript",
+    "version": "0.0.1-dev.008d8ef",
+    "description": "A typescript library for Warcraft III using Warpack.",
+    "keywords": [
+        "warcraft",
+        "warscript"
+    ],
+    "license": "MIT",
+    "author": "rhazarian",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/rhazarian/warscript.git"
+    },
+    "scripts": {
+        "clean": "rimraf dist",
+        "prebuild": "npm run clean",
+        "build": "tstl && copyfiles -u 1 \"src/**/*.d.ts\" \"src/**/*.lua\" dist && copyfiles LICENSE package.json dist",
+        "prepublishOnly": "echo You should run 'npm run publish' instead. && exit 1",
+        "publish": "npm run build && npm publish ./dist --ignore-scripts"
+    },
+    "peerDependencies": {
+        "@warscript/language-extensions": "^0.0.1",
+        "@warscript/tstl-plugin": "^0.0.4",
+        "lua-types": "^2.13.1",
+        "warpack": "0.0.1-dev.2c4e71e"
+    },
+    "devDependencies": {
+        "@typescript-eslint/eslint-plugin": "^8.13.0",
+        "@typescript-eslint/parser": "^8.13.0",
+        "async": "^3.2.6",
+        "copyfiles": "^2.4.1",
+        "eslint": "^9.14.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.2.1",
+        "prettier": "^3.3.3",
+        "rimraf": "^6.0.1",
+        "ts-node": "^10.9.2",
+        "tsc-watch": "^6.2.0"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
+}

package/patch-lualib.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+export {};

package/patch-lualib.lua

@@ -0,0 +1,67 @@
+local ____exports = {}
+local lualib = _G.require("lualib_bundle")
+local next = _G.next
+local ____type = _G.type
+lualib.__TS__ArrayIsArray = function(value)
+    return ____type(value) == "table" and (value[1] ~= nil or ({next(value)}) == nil) and value.constructor == nil
+end
+local __TS__SetDescriptor = lualib.__TS__SetDescriptor
+lualib.__TS__ObjectDefineProperty = function(target, key, desc)
+    local luaKey = type(key) == "number" and key + 1 or key
+    local value = rawget(target, luaKey)
+    local hasGetterOrSetter = desc.get ~= nil or desc.set ~= nil
+    local descriptor
+    if hasGetterOrSetter then
+        if value ~= nil then
+            error(
+                "Cannot redefine property: " .. tostring(key),
+                0
+            )
+        end
+        descriptor = desc
+    else
+        local valueExists = value ~= nil
+        local ____desc_set_4 = desc.set
+        local ____desc_get_5 = desc.get
+        local ____temp_0
+        if desc.configurable ~= nil then
+            ____temp_0 = desc.configurable
+        else
+            ____temp_0 = valueExists
+        end
+        local ____temp_1
+        if desc.enumerable ~= nil then
+            ____temp_1 = desc.enumerable
+        else
+            ____temp_1 = valueExists
+        end
+        local ____temp_2
+        if desc.writable ~= nil then
+            ____temp_2 = desc.writable
+        else
+            ____temp_2 = valueExists
+        end
+        local ____temp_3
+        if desc.value ~= nil then
+            ____temp_3 = desc.value
+        else
+            ____temp_3 = value
+        end
+        descriptor = {
+            set = ____desc_set_4,
+            get = ____desc_get_5,
+            configurable = ____temp_0,
+            enumerable = ____temp_1,
+            writable = ____temp_2,
+            value = ____temp_3
+        }
+    end
+    __TS__SetDescriptor(
+        target,
+        luaKey,
+        descriptor,
+        ____type(target.constructor) == "table" and target.constructor.prototype == target
+    )
+    return target
+end
+return ____exports

package/patch-natives.d.ts

@@ -0,0 +1,11 @@
+/** @noSelfInFile */
+declare global {
+    type oskeymeta = {
+        readonly __oskeymeta: unique symbol;
+    } & number;
+    const OSKEY_META_NONE: oskeymeta;
+    const OSKEY_META_SHIFT: oskeymeta;
+    const OSKEY_META_CTRL: oskeymeta;
+    const OSKEY_META_ALT: oskeymeta;
+}
+export {};

package/patch-natives.lua

@@ -0,0 +1,14 @@
+local ____exports = {}
+do
+    local g = _G
+    g.OSKEY_META_NONE = 0
+    g.OSKEY_META_SHIFT = 1
+    g.OSKEY_META_CTRL = 2
+    g.OSKEY_META_ALT = 4
+end
+compiletime(function()
+    _G.GetLocalizedString = function(source)
+        return currentMap and currentMap.strings:localized(source) or source
+    end
+end)
+return ____exports

package/property.d.ts

@@ -0,0 +1,55 @@
+/** @noSelfInFile */
+import { Player } from "./core/types/player";
+import { Event } from "./event";
+export declare class PersistentPropertiesConfig {
+    static defaultFileName: string;
+}
+declare const enum PropertyPropertyKey {
+    DEFAULT_VALUE = 0,
+    VALUE = 1,
+    IS_CHANGED = 2
+}
+export declare class Property<T> {
+    readonly valueChangeEvent: Event<[newValue: T, oldValue: T]>;
+    private [PropertyPropertyKey.DEFAULT_VALUE];
+    private [PropertyPropertyKey.VALUE];
+    private [PropertyPropertyKey.IS_CHANGED]?;
+    constructor(defaultValue: T);
+    get defaultValue(): T;
+    set defaultValue(defaultValue: T);
+    get value(): T;
+    set value(value: T);
+    get isChanged(): boolean;
+    reset(): boolean;
+    set(value: T): boolean;
+    get(): T;
+}
+declare const enum PlayerPropertyPropertyKey {
+    DEFAULT_VALUE = 0,
+    VALUE_BY_PLAYER = 1,
+    IS_CHANGED_BY_PLAYER = 2
+}
+export declare class PlayerProperty<T> {
+    readonly valueChangeEvent: Event<[player: Player, newValue: T, oldValue: T]>;
+    private readonly [PlayerPropertyPropertyKey.DEFAULT_VALUE];
+    private readonly [PlayerPropertyPropertyKey.VALUE_BY_PLAYER];
+    private readonly [PlayerPropertyPropertyKey.IS_CHANGED_BY_PLAYER];
+    constructor(defaultValue: T);
+    isChanged(player: Player): boolean;
+    reset(player: Player): boolean;
+    set(player: Player, value: T): boolean;
+    get(player: Player): T;
+}
+export declare class PersistentProperty<T extends undefined | boolean | number | string> extends Property<T> {
+    readonly id: number;
+    constructor(id: number, defaultValue: T, valueChangeEventListener?: (newValue: T, oldValue: T) => void);
+    reset(): boolean;
+    set(value: T): boolean;
+}
+export declare class PersistentPlayerProperty<T extends string | number | boolean> extends PlayerProperty<T> {
+    readonly id: number;
+    constructor(id: number, initialValue: T, valueChangeEventListener?: (player: Player, newValue: T, oldValue: T) => void);
+    reset(player: Player): boolean;
+    set(player: Player, value: T): boolean;
+}
+export {};