warscript 0.0.1-dev.632c807 → 0.0.1-dev.a12bd26

package/engine/object-data/entry/ability-type/engineering-upgrade.lua

@@ -7,7 +7,7 @@ local ____exports = {}
 local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
 local AbilityType = ____ability_2Dtype.AbilityType
 local ____arrays = require("utility.arrays")
-local EMPTY_ARRAY = ____arrays.EMPTY_ARRAY
+local emptyArray = ____arrays.emptyArray
 local map = ____arrays.map
 local ____buff_2Dtype = require("engine.object-data.entry.buff-type")
 local BuffType = ____buff_2Dtype.BuffType
@@ -78,7 +78,7 @@ __TS__SetDescriptor(
                         function(levelAbilityUpgrades)
                             return levelAbilityUpgrades[i + 1]
                         end
-                    ) or (abilityUpgrades[i + 1] or EMPTY_ARRAY)
+                    ) or (abilityUpgrades[i + 1] or emptyArray())
                 )
             end
         end

package/engine/object-field.d.ts

@@ -33,7 +33,7 @@ export type ObjectFieldValueChangeEvent<T extends ObjectField<any, any, any, any
     previousValue: ValueType,
     newValue: ValueType
 ]> : never;
-export type ReadonlyObjectFieldType<T extends ObjectField<any, any, any, any>> = Omit<T, "setValue" | "removeValue">;
+export type ReadonlyObjectFieldType<T extends ObjectField<any, any, any, any>> = Omit<T, "setValue" | "removeValue" | "trySetValue">;
 type ReadonlyObjectFieldConstructor<T extends ObjectField> = OmitConstructor<typeof ObjectField> & (abstract new (...args: any[]) => ReadonlyObjectFieldType<T>);
 export declare abstract class ObjectField<ObjectDataEntryType extends ObjectDataEntry = ObjectDataEntry, InstanceType extends AnyNotNil = AnyNotNil, ValueType extends number | string | boolean = number | string | boolean, NativeFieldType = unknown> extends ObjectFieldBase<ObjectDataEntryType, InstanceType, ValueType, NativeFieldType> {
     protected abstract readonly defaultValue: ValueType;
@@ -42,12 +42,13 @@ export declare abstract class ObjectField<ObjectDataEntryType extends ObjectData
     getValue(entry: ObjectDataEntryType | InstanceType): ValueType;
     setValue(entry: ObjectDataEntryType | InstanceType, value: ValueType): boolean;
     removeValue(entry: ObjectDataEntryType): boolean;
+    trySetValue(entry: ObjectDataEntryType | InstanceType, value: unknown): boolean;
     private invokeValueChangeEvent;
     private invokeValueChangeEventRecursive;
     protected static getOrCreateValueChangeEvent<T extends ObjectField, R extends ReadonlyObjectFieldType<T>>(this: ReadonlyObjectFieldConstructor<T>): ObjectFieldValueChangeEvent<R>;
     static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<ObjectField>>;
 }
-export type ReadonlyObjectLevelFieldType<T extends ObjectLevelField<any, any, any, any>> = Omit<T, "setValue">;
+export type ReadonlyObjectLevelFieldType<T extends ObjectLevelField<any, any, any, any>> = Omit<T, "setValue" | "trySetValue">;
 export type ObjectLevelFieldValueChangeEvent<T extends ObjectLevelField<any, any, any, any> | ReadonlyObjectLevelFieldType<ObjectLevelField<any, any, any, any>>> = T extends ObjectLevelField<any, infer InstanceType, infer ValueType, any, any> ? DispatchingEvent<[
     instance: InstanceType,
     field: T,
@@ -76,6 +77,7 @@ export declare abstract class ObjectLevelField<ObjectDataEntryType extends Objec
     protected abstract getLevelCount(entry: ObjectDataEntryType | InstanceType): number;
     getValue<LevelType extends [number] | []>(entry: ObjectDataEntryType | InstanceType, ...[level]: LevelType): LevelType extends [number] ? ValueType : ValueType[];
     setValue(entry: ObjectDataEntryType | InstanceType, ...[levelOrValue, value]: [value: ObjectDataEntryLevelFieldValueSupplier<InputValueType, ValueType>] | [level: number, value: InputValueType]): boolean;
+    trySetValue(entry: ObjectDataEntryType | InstanceType, levelOrValue: number | unknown, value?: unknown): boolean;
     private invokeValueChangeEvent;
     private invokeValueChangeEventRecursive;
     protected static getOrCreateValueChangeEvent<T extends ObjectLevelField, R extends ReadonlyObjectLevelFieldType<T>>(this: ReadonlyObjectLevelFieldConstructor<T>): ObjectLevelFieldValueChangeEvent<R>;

package/engine/object-field.lua

@@ -4,6 +4,7 @@ local __TS__Class = ____lualib.__TS__Class
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__TypeOf = ____lualib.__TS__TypeOf
 local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
 local ____exports = {}
 local ____event = require("event")
@@ -155,6 +156,12 @@ function ObjectField.prototype.removeValue(self, entry)
     end
     return false
 end
+function ObjectField.prototype.trySetValue(self, entry, value)
+    if __TS__TypeOf(value) ~= __TS__TypeOf(self.defaultValue) then
+        return false
+    end
+    return self:setValue(entry, value)
+end
 function ObjectField.prototype.invokeValueChangeEvent(self, ...)
     self:invokeValueChangeEventRecursive(
         getClass(self),
@@ -399,6 +406,21 @@ function ObjectLevelField.prototype.setValue(self, entry, levelOrValue, value)
     end
     return true
 end
+function ObjectLevelField.prototype.trySetValue(self, entry, levelOrValue, value)
+    if value ~= nil then
+        if __TS__TypeOf(value) ~= __TS__TypeOf(self.defaultValue) then
+            return false
+        end
+        if type(levelOrValue) ~= "number" then
+            return false
+        end
+        return self:setValue(entry, levelOrValue, value)
+    end
+    if __TS__TypeOf(levelOrValue) ~= __TS__TypeOf(self.defaultValue) then
+        return false
+    end
+    return self:setValue(entry, levelOrValue)
+end
 function ObjectLevelField.prototype.invokeValueChangeEvent(self, ...)
     self:invokeValueChangeEventRecursive(
         getClass(self),

package/exception.d.ts

@@ -15,3 +15,5 @@ export declare class IllegalStateException extends Exception {
 }
 export declare class CancellationException extends Exception {
 }
+export declare class UnsupportedOperationException extends Exception {
+}

package/exception.lua

@@ -50,4 +50,8 @@ ____exports.CancellationException = __TS__Class()
 local CancellationException = ____exports.CancellationException
 CancellationException.name = "CancellationException"
 __TS__ClassExtends(CancellationException, ____exports.Exception)
+____exports.UnsupportedOperationException = __TS__Class()
+local UnsupportedOperationException = ____exports.UnsupportedOperationException
+UnsupportedOperationException.name = "UnsupportedOperationException"
+__TS__ClassExtends(UnsupportedOperationException, ____exports.Exception)
 return ____exports

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.632c807",
+    "version": "0.0.1-dev.a12bd26",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",
@@ -25,7 +25,7 @@
         "@warscript/tstl-plugin": "^0.0.1",
         "typescript-to-lua": "^1.24.1",
         "lua-types": "^2.13.1",
-        "warpack": "0.0.1-dev.559048d"
+        "warpack": "0.0.1-dev.5bdabe5"
     },
     "devDependencies": {
         "@typescript-eslint/eslint-plugin": "^5.59.11",

package/utility/arrays.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 import { TupleOf } from "./types";
-export declare const EMPTY_ARRAY: readonly any[];
+export declare const emptyArray: <T>() => readonly T[];
 export declare const joinToString: <T>(array: readonly T[], separator: string, transform?: (element: T) => string) => string;
 export declare const arrayOfNotNull: <T>(...elements: readonly (T | null | undefined)[]) => T[];
 export declare const array: <T, N extends number>(length: N, initialize: (index: number) => T) => TupleOf<T, N>;

package/utility/arrays.lua

@@ -8,7 +8,10 @@ local mathMin = math.min
 local select = _G.select
 local tableConcat = table.concat
 local tableSort = table.sort
-____exports.EMPTY_ARRAY = {}
+local EMPTY_ARRAY = {}
+____exports.emptyArray = function()
+    return EMPTY_ARRAY
+end
 ____exports.joinToString = function(array, separator, transform)
     if transform == nil then
         transform = tostring

package/utility/linked-set.d.ts

@@ -4,10 +4,25 @@ type IteratorState<T extends AnyNotNil> = {
     t: LuaMap<T, T>;
     n?: T;
 };
-export interface LinkedSet<T> extends LuaPairsKeyIterable<T> {
-    readonly __linkedHashSet: unique symbol;
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface ReadonlyLinkedSet<T extends AnyNotNil> extends LuaPairsKeyIterable<T> {
+    copyOf(): LinkedSet<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    next(key: T): T | undefined;
+    previous(key: T): T | undefined;
+    contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
+    size: number;
+    forEach<Args extends any[]>(action: (value: T, ...args: Args) => void, ...args: Args): void;
+    toArray(): T[];
+    sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
+}
+export interface LinkedSet<T extends AnyNotNil> extends LuaPairsKeyIterable<T> {
+    readonly __linkedSet: unique symbol;
 }
-export declare class LinkedSet<T extends AnyNotNil> {
+export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet<T> {
     private n;
     private p;
     private f?;
@@ -20,9 +35,7 @@ export declare class LinkedSet<T extends AnyNotNil> {
     previous(key: T): T | undefined;
     add(key: T): boolean;
     remove(key: T): boolean;
-    contains(key: AnyNotNil): key is T & {
-        readonly __oneSidedTypeGuard: unique symbol;
-    };
+    contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
     clear(): void;
     get size(): number;
     forEach<Args extends any[]>(action: (value: T, ...args: Args) => void, ...args: Args): void;