warscript 0.0.1-dev.aaf0a9d → 0.0.1-dev.b530e1f

package/engine/object-data/entry/ability-type.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="warpack-types/warpack" />
 /** @noSelfInFile */
+import "../../internal/unit/ability";
 import { TupleOf } from "../../../utility/types";
 import { AnimationName } from "../auxiliary/animation-name";
 import { AnimationQualifier } from "../auxiliary/animation-qualifier";

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

@@ -6,6 +6,7 @@ local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
 local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
+require("engine.internal.unit.ability")
 local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____effect = require("core.types.effect")

package/engine/object-field.d.ts

@@ -9,7 +9,6 @@ export type ObjectFieldId = number & {
 export type ObjectFieldConstructor<T extends ObjectFieldBase<any, any, any, any>> = OmitConstructor<typeof ObjectFieldBase> & (new (id: number) => T);
 export type ObjectFieldAbstractConstructor<T extends ObjectFieldBase<any, any, any, any>> = OmitConstructor<typeof ObjectFieldBase> & (abstract new (id: number) => T);
 declare abstract class ObjectFieldBase<ObjectDataEntryType extends ObjectDataEntry, InstanceType extends AnyNotNil, ValueType, NativeFieldType> {
-    protected readonly valueByInstance: LuaMap<InstanceType, ValueType>;
     protected abstract readonly instanceClass: AbstractConstructor<InstanceType> | Function;
     supports(instance: AnyNotNil): instance is InstanceType & {
         readonly __oneSidedTypeGuard: unique symbol;
@@ -33,22 +32,22 @@ 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;
-    accepts(value: unknown): value is ValueType;
     protected abstract getNativeFieldValue(instance: InstanceType): ValueType;
     protected abstract setNativeFieldValue(instance: InstanceType, value: ValueType): boolean;
     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,
@@ -77,6 +76,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

@@ -71,9 +71,6 @@ ____exports.ObjectField = __TS__Class()
 local ObjectField = ____exports.ObjectField
 ObjectField.name = "ObjectField"
 __TS__ClassExtends(ObjectField, ObjectFieldBase)
-function ObjectField.prototype.accepts(self, value)
-    return __TS__TypeOf(value) == __TS__TypeOf(self.defaultValue)
-end
 function ObjectField.prototype.getValue(self, entry)
     if __TS__InstanceOf(entry, ObjectDataEntry) then
         local defaultValueByObjectDataEntryId = (warpack.compiletime and compiletimeDefaultValueByObjectDataEntryIdByObjectFieldId or defaultValueByObjectDataEntryIdByObjectFieldId)[self.id]
@@ -159,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),
@@ -403,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/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.aaf0a9d",
+    "version": "0.0.1-dev.b530e1f",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",

package/utility/linked-set.d.ts

@@ -44,6 +44,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     sortBy<R>(selector: ((value: T) => R) | KeysOfType<T, R>): void;
     protected __pairs(this: LinkedSet<T>): LuaIterator<T | undefined, IteratorState<T>>;
 }
+export declare const emptyLinkedSet: <T extends AnyNotNil>() => ReadonlyLinkedSet<T>;
 export declare const linkedSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LinkedSet<T>;
 export declare const linkedSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | null | undefined)[]) => LinkedSet<T>;
 export {};

package/utility/linked-set.lua

@@ -2,9 +2,12 @@ local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local __TS__New = ____lualib.__TS__New
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
 local ____exports = {}
 local ____arrays = require("utility.arrays")
 local sortBy = ____arrays.sortBy
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
 local function linkedSetNext(state)
     local n = state.n
     state.n = state.t[n]
@@ -161,6 +164,19 @@ __TS__SetDescriptor(
     end},
     true
 )
+local EmptyLinkedSet = __TS__Class()
+EmptyLinkedSet.name = "EmptyLinkedSet"
+__TS__ClassExtends(EmptyLinkedSet, ____exports.LinkedSet)
+function EmptyLinkedSet.prototype.add(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
+____exports.emptyLinkedSet = function()
+    return EMPTY_LINKED_SET
+end
 ____exports.linkedSetOf = function(...)
     local linkedSet = __TS__New(____exports.LinkedSet)
     for i = 1, select("#", ...) do