warscript 0.0.1-dev.404878c

package/engine/object-data/entry.lua

@@ -0,0 +1,634 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectAssign = ____lualib.__TS__ObjectAssign
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__InstanceOf = ____lualib.__TS__InstanceOf
+local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__StringSplit = ____lualib.__TS__StringSplit
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local ____exports = {}
+local booleanToData, dataToBoolean, numberToData, dataToNumber, stringToData, dataToString, objectDataEntryIdToData, dataToObjectDataEntryId, booleansToData, dataToBooleans, numbersToData, dataToNumbers, stringsToData, dataToStrings, objectDataEntryIdsToData, dataToObjectDataEntryIds, isDataNotBlank
+local ____attachment_2Dpreset = require("engine.object-data.auxiliary.attachment-preset")
+local extractAttachmentPresetInputModelPath = ____attachment_2Dpreset.extractAttachmentPresetInputModelPath
+local extractAttachmentPresetInputNodeFQN = ____attachment_2Dpreset.extractAttachmentPresetInputNodeFQN
+local splitAttachmentNodeFQN = ____attachment_2Dpreset.splitAttachmentNodeFQN
+local ____exception = require("exception")
+local IllegalStateException = ____exception.IllegalStateException
+local ____arrays = require("utility.arrays")
+local map = ____arrays.map
+local zip = ____arrays.zip
+local ____preconditions = require("utility.preconditions")
+local check = ____preconditions.check
+local ____math = require("math")
+local max = ____math.max
+____exports.extractObjectDataEntryLevelFieldValue = function(supplier, level, currentValue)
+    local ____Array_isArray_result_1
+    if __TS__ArrayIsArray(supplier) then
+        ____Array_isArray_result_1 = supplier[level + 1]
+    else
+        local ____temp_0
+        if type(supplier) == "function" then
+            ____temp_0 = supplier(level, currentValue)
+        else
+            ____temp_0 = supplier
+        end
+        ____Array_isArray_result_1 = ____temp_0
+    end
+    return ____Array_isArray_result_1
+end
+____exports.extractObjectDataEntryLevelArrayFieldValue = function(supplier, level, currentValue)
+    return type(supplier) == "function" and supplier(level, currentValue) or (__TS__ArrayIsArray(supplier[1]) and supplier[1] or supplier)
+end
+local objectDataEntryByObjectDataEntryId = {}
+local internalObjectDataEntryIds = {}
+____exports.ObjectDataEntry = __TS__Class()
+local ObjectDataEntry = ____exports.ObjectDataEntry
+ObjectDataEntry.name = "ObjectDataEntry"
+function ObjectDataEntry.prototype.____constructor(self, object)
+    self.object = object
+    self.levelFieldParametersByField = {}
+    self.maxAffectedLevelByField = {}
+    self._isInternal = false
+    if not warpack.compiletime then
+        error(
+            __TS__New(IllegalStateException, "Object data entries cannot be constructed in runtime."),
+            0
+        )
+    end
+    objectDataEntryByObjectDataEntryId[self.id] = self
+end
+function ObjectDataEntry.generateId(self)
+    error(
+        __TS__New(IllegalStateException, "An object type definition must override the 'generateId' static method."),
+        0
+    )
+end
+function ObjectDataEntry.getObjectData(self, map)
+    error(
+        __TS__New(IllegalStateException, "An object type definition must override the 'getObjectData' static method."),
+        0
+    )
+end
+function ObjectDataEntry.getAllIdsByBaseIds(self, baseIds)
+    return map(
+        self:getAllByBaseIds(baseIds),
+        "id"
+    )
+end
+function ObjectDataEntry.create(self, id, properties)
+    if type(id) == "table" then
+        id = nil
+        properties = id
+    end
+    if currentMap == nil then
+        error(
+            __TS__New(IllegalStateException, "Cannot create a new object type when not compiling a map."),
+            0
+        )
+    end
+    local constructor = self
+    local registry = constructor:getObjectData(currentMap)
+    local baseId = self.BASE_ID
+    if baseId == 0 then
+        error(
+            __TS__New(IllegalStateException, "An object type definition must override the BASE_ID static property."),
+            0
+        )
+    end
+    local object = registry:newObject(
+        objectDataEntryIdToData(id or constructor:generateId()),
+        objectDataEntryIdToData(baseId)
+    )
+    local objectDataEntry = __TS__New(self, object)
+    if properties ~= nil then
+        __TS__ObjectAssign(objectDataEntry, properties)
+    end
+    return objectDataEntry
+end
+function ObjectDataEntry.getAllByBaseIds(self, baseIds)
+    if currentMap == nil then
+        return {}
+    end
+    local dataBaseIds = {}
+    if __TS__ArrayIsArray(baseIds) then
+        for ____, baseId in ipairs(baseIds) do
+            dataBaseIds[objectDataEntryIdToData(baseId)] = true
+        end
+    else
+        dataBaseIds[objectDataEntryIdToData(baseIds)] = true
+    end
+    local result = {}
+    local constructor = self
+    for id, object in pairs(constructor:getObjectData(currentMap).all) do
+        if dataBaseIds[object.parentId or id] ~= nil then
+            local objectDataEntry = self:of(dataToObjectDataEntryId(id))
+            if objectDataEntry ~= nil and not objectDataEntry.isInternal then
+                result[#result + 1] = objectDataEntry
+            end
+        end
+    end
+    return result
+end
+function ObjectDataEntry.getAll(self)
+    if currentMap == nil then
+        return {}
+    end
+    local constructor = self
+    local result = {}
+    for id in pairs(constructor:getObjectData(currentMap).all) do
+        local objectDataEntry = self:of(dataToObjectDataEntryId(id))
+        if objectDataEntry ~= nil and not objectDataEntry.isInternal then
+            result[#result + 1] = objectDataEntry
+        end
+    end
+    return result
+end
+function ObjectDataEntry.of(self, id)
+    if currentMap == nil then
+        return nil
+    end
+    local constructor = self
+    local registry = constructor:getObjectData(currentMap)
+    local object = registry:getObject(objectDataEntryIdToData(id))
+    if object == nil then
+        return nil
+    end
+    local objectDataEntry = objectDataEntryByObjectDataEntryId[dataToObjectDataEntryId(object.id)]
+    if objectDataEntry == nil then
+        if not constructor.IS_SYNTHETIC and (self.BASE_ID == 0 or dataToObjectDataEntryId(object.parentId) == self.BASE_ID) then
+            local AbstractObjectDataEntryView = __TS__Class()
+            AbstractObjectDataEntryView.name = "AbstractObjectDataEntryView"
+            __TS__ClassExtends(AbstractObjectDataEntryView, constructor)
+            function AbstractObjectDataEntryView.prototype.____constructor(self, object)
+                constructor.prototype.____constructor(self, object)
+            end
+            objectDataEntry = __TS__New(AbstractObjectDataEntryView, object)
+        else
+            return nil
+        end
+    elseif not __TS__InstanceOf(objectDataEntry, self) then
+        return nil
+    end
+    return objectDataEntry
+end
+function ObjectDataEntry.prototype.getFieldValue(self, field, ...)
+    return field:getValue(self, ...)
+end
+function ObjectDataEntry.prototype.setFieldValue(self, field, ...)
+    check(field:setValue(self, ...))
+end
+function ObjectDataEntry.prototype.getBooleanField(self, field)
+    return dataToBoolean(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setBooleanField(self, field, value)
+    self.object:setField(
+        field,
+        booleanToData(value)
+    )
+end
+function ObjectDataEntry.prototype.getNumberField(self, field)
+    return dataToNumber(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setNumberField(self, field, value)
+    self.object:setField(
+        field,
+        numberToData(value)
+    )
+    if field == "levels" or field == "maxlevel" or field == "alev" or field == "glvl" then
+        for otherField, levelFieldParameters in pairs(self.levelFieldParametersByField) do
+            local ____levelFieldParameters_2 = levelFieldParameters
+            local supplier = ____levelFieldParameters_2.supplier
+            local extractor = ____levelFieldParameters_2.extractor
+            local dataToValue = ____levelFieldParameters_2.dataToValue
+            local valueToData = ____levelFieldParameters_2.valueToData
+            local maxAffectedLevel = self.maxAffectedLevelByField[otherField] or 0
+            if value > maxAffectedLevel then
+                self.maxAffectedLevelByField[otherField] = value
+                for level = maxAffectedLevel + 1, value do
+                    local value = extractor(
+                        supplier,
+                        level - 1,
+                        dataToValue(self.object:getField((otherField .. "+") .. tostring(level)))
+                    )
+                    self.object:setField(
+                        (otherField .. "+") .. tostring(level),
+                        valueToData(value)
+                    )
+                end
+            end
+        end
+    end
+end
+function ObjectDataEntry.prototype.getStringField(self, field)
+    return dataToString(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setStringField(self, field, value)
+    self.object:setField(
+        field,
+        stringToData(value)
+    )
+end
+function ObjectDataEntry.prototype.getObjectDataEntryIdField(self, field)
+    return dataToObjectDataEntryId(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setObjectDataEntryIdField(self, field, value)
+    self.object:setField(
+        field,
+        objectDataEntryIdToData(value)
+    )
+end
+function ObjectDataEntry.prototype.getAttachmentPresetField(self, modelPathField, nodeFQNField)
+    local modelPath = self:getStringField(modelPathField)
+    if modelPath ~= "" then
+        local nodeName, nodeQualifiers = splitAttachmentNodeFQN(self:getStringField(nodeFQNField))
+        return {modelPath = modelPath, nodeName = nodeName, nodeQualifiers = nodeQualifiers}
+    end
+    return nil
+end
+function ObjectDataEntry.prototype.setAttachmentPresetField(self, modelPathField, nodeFQNField, attachmentPreset)
+    self:setStringField(
+        modelPathField,
+        extractAttachmentPresetInputModelPath(attachmentPreset)
+    )
+    self:setStringField(
+        nodeFQNField,
+        extractAttachmentPresetInputNodeFQN(attachmentPreset)
+    )
+end
+function ObjectDataEntry.prototype.getBooleansField(self, field)
+    return dataToBooleans(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setBooleansField(self, field, values)
+    self.object:setField(
+        field,
+        booleansToData(values)
+    )
+end
+function ObjectDataEntry.prototype.getNumbersField(self, field)
+    return dataToNumbers(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setNumbersField(self, field, values)
+    self.object:setField(
+        field,
+        numbersToData(values)
+    )
+end
+function ObjectDataEntry.prototype.getStringsField(self, field)
+    return dataToStrings(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setStringsField(self, field, values)
+    self.object:setField(
+        field,
+        stringsToData(values)
+    )
+end
+function ObjectDataEntry.prototype.getObjectDataEntryIdsField(self, field)
+    return dataToObjectDataEntryIds(self.object:getField(field))
+end
+function ObjectDataEntry.prototype.setObjectDataEntryIdsField(self, field, values)
+    self.object:setField(
+        field,
+        objectDataEntryIdsToData(values)
+    )
+end
+function ObjectDataEntry.prototype.getAttachmentPresetListField(self, modelPathListField, nodeFQNFields)
+    local modelPaths = self:getStringsField(modelPathListField)
+    return zip(
+        modelPaths,
+        nodeFQNFields,
+        function(modelPath, nodeFQNField)
+            local nodeName, nodeQualifiers = splitAttachmentNodeFQN(self:getStringField(nodeFQNField))
+            return {modelPath = modelPath, nodeName = nodeName, nodeQualifiers = nodeQualifiers}
+        end
+    )
+end
+function ObjectDataEntry.prototype.setAttachmentPresetListField(self, modelPathListField, nodeFQNFields, lengthField, attachmentPresets)
+    self:setStringsField(
+        modelPathListField,
+        map(attachmentPresets, extractAttachmentPresetInputModelPath)
+    )
+    for i = 0, #nodeFQNFields - 1 do
+        self:setStringField(
+            nodeFQNFields[i + 1],
+            extractAttachmentPresetInputNodeFQN(attachmentPresets[i + 1])
+        )
+    end
+    self:setNumberField(lengthField, #attachmentPresets)
+end
+function ObjectDataEntry.prototype.setFlagLevelFieldValue(self, fieldId, flag, supplier)
+    self:setNumberLevelField(
+        fieldId,
+        function(level, currentValue)
+            local value = ____exports.extractObjectDataEntryLevelFieldValue(supplier, level, currentValue & flag ~= 0)
+            return currentValue & ~flag | (value and flag or 0)
+        end
+    )
+end
+function ObjectDataEntry.prototype.getFlagLevelFieldValue(self, fieldId, flag)
+    return __TS__ArrayMap(
+        self:getNumberLevelField(fieldId),
+        function(____, value) return value & flag ~= 0 end
+    )
+end
+function ObjectDataEntry.prototype.getBooleanLevelField(self, field)
+    return self:getLevelField(field, dataToBoolean)
+end
+function ObjectDataEntry.prototype.setBooleanLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelFieldValue,
+        dataToBoolean,
+        booleanToData
+    )
+end
+function ObjectDataEntry.prototype.getNumberLevelField(self, field)
+    return self:getLevelField(field, dataToNumber)
+end
+function ObjectDataEntry.prototype.setNumberLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelFieldValue,
+        dataToNumber,
+        numberToData
+    )
+end
+function ObjectDataEntry.prototype.getStringLevelField(self, field)
+    return self:getLevelField(field, dataToString)
+end
+function ObjectDataEntry.prototype.setStringLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelFieldValue,
+        dataToString,
+        stringToData
+    )
+end
+function ObjectDataEntry.prototype.getObjectDataEntryIdLevelField(self, field)
+    return self:getLevelField(field, dataToObjectDataEntryId)
+end
+function ObjectDataEntry.prototype.setObjectDataEntryIdLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelFieldValue,
+        dataToObjectDataEntryId,
+        objectDataEntryIdToData
+    )
+end
+function ObjectDataEntry.prototype.getBooleansLevelField(self, field)
+    return self:getLevelField(field, dataToBooleans)
+end
+function ObjectDataEntry.prototype.setBooleansLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelArrayFieldValue,
+        dataToBooleans,
+        booleansToData
+    )
+end
+function ObjectDataEntry.prototype.getNumbersLevelField(self, field)
+    return self:getLevelField(field, dataToNumbers)
+end
+function ObjectDataEntry.prototype.setNumbersLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelArrayFieldValue,
+        dataToNumbers,
+        numbersToData
+    )
+end
+function ObjectDataEntry.prototype.getStringsLevelField(self, field)
+    return self:getLevelField(field, dataToStrings)
+end
+function ObjectDataEntry.prototype.setStringsLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelArrayFieldValue,
+        dataToStrings,
+        stringsToData
+    )
+end
+function ObjectDataEntry.prototype.getObjectDataEntryIdsLevelField(self, field)
+    return self:getLevelField(field, dataToObjectDataEntryIds)
+end
+function ObjectDataEntry.prototype.setObjectDataEntryIdsLevelField(self, field, values)
+    self:setLevelField(
+        field,
+        values,
+        ____exports.extractObjectDataEntryLevelArrayFieldValue,
+        dataToObjectDataEntryIds,
+        objectDataEntryIdsToData
+    )
+end
+function ObjectDataEntry.prototype.getLevelField(self, field, dataToValue)
+    local values = {}
+    local object = self.object
+    for level = 1, tonumber(object:getField("levels")) or 1 do
+        values[level] = dataToValue(object:getField((field .. "+") .. tostring(level)))
+    end
+    return values
+end
+function ObjectDataEntry.prototype.setLevelField(self, field, supplier, extractor, dataToValue, valueToData)
+    local levelFieldParameters = {supplier = supplier, extractor = extractor, dataToValue = dataToValue, valueToData = valueToData}
+    if type(supplier) == "function" then
+        local previousLevelFieldParameters = self.levelFieldParametersByField[field]
+        if previousLevelFieldParameters ~= nil then
+            local previousSupplier = previousLevelFieldParameters.supplier
+            levelFieldParameters.supplier = function(level, currentValue)
+                return supplier(
+                    level,
+                    extractor(previousSupplier, level, currentValue)
+                )
+            end
+            levelFieldParameters.dataToValue = previousLevelFieldParameters.dataToValue
+        end
+    end
+    self.levelFieldParametersByField[field] = levelFieldParameters
+    local object = self.object
+    local maxAffectedLevel = max(
+        self.maxAffectedLevelByField[field] or 0,
+        tonumber(object:getField("levels")) or tonumber(object:getField("maxlevel")) or 0
+    )
+    self.maxAffectedLevelByField[field] = maxAffectedLevel
+    for level = 1, maxAffectedLevel do
+        local value = extractor(
+            supplier,
+            level - 1,
+            dataToValue(object:getField((field .. "+") .. tostring(level)))
+        )
+        object:setField(
+            (field .. "+") .. tostring(level),
+            valueToData(value)
+        )
+    end
+end
+ObjectDataEntry.BASE_ID = 0
+ObjectDataEntry.IS_SYNTHETIC = false
+__TS__SetDescriptor(
+    ObjectDataEntry.prototype,
+    "isInternal",
+    {
+        get = function(self)
+            return self._isInternal
+        end,
+        set = function(self, isInternal)
+            if isInternal then
+                internalObjectDataEntryIds[self.id] = true
+            else
+                internalObjectDataEntryIds[self.id] = nil
+            end
+            self._isInternal = isInternal
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ObjectDataEntry.prototype,
+    "id",
+    {get = function(self)
+        return dataToObjectDataEntryId(self.object.id)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    ObjectDataEntry.prototype,
+    "baseId",
+    {get = function(self)
+        return dataToObjectDataEntryId(self.object.parentId or self.object.id)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    ObjectDataEntry.prototype,
+    "isCustom",
+    {get = function(self)
+        return self.object.parentId ~= nil
+    end},
+    true
+)
+booleanToData = function(value)
+    return value and 1 or 0
+end
+dataToBoolean = function(data)
+    return (tonumber(data) or 0) == 1
+end
+numberToData = function(value)
+    return value
+end
+dataToNumber = function(data)
+    return tonumber(data) or 0
+end
+stringToData = function(value)
+    return value
+end
+dataToString = function(data)
+    return tostring(data or "")
+end
+objectDataEntryIdToData = function(value)
+    return value == 0 and "" or string.pack(">I4", value)
+end
+dataToObjectDataEntryId = function(data)
+    local dataString = dataToString(data)
+    if isDataNotBlank(nil, dataString) then
+        return (string.unpack(">I4", dataString))
+    else
+        return 0
+    end
+end
+booleansToData = function(value)
+    return table.concat(
+        __TS__ArrayMap(
+            value,
+            function(____, boolean) return booleanToData(boolean) end
+        ),
+        ","
+    )
+end
+dataToBooleans = function(data)
+    return __TS__ArrayMap(
+        __TS__ArrayFilter(
+            __TS__StringSplit(
+                dataToString(data),
+                ","
+            ),
+            isDataNotBlank
+        ),
+        function(____, data) return dataToBoolean(data) end
+    )
+end
+numbersToData = function(value)
+    return table.concat(
+        __TS__ArrayMap(
+            value,
+            function(____, number) return numberToData(number) end
+        ),
+        ","
+    )
+end
+dataToNumbers = function(data)
+    return __TS__ArrayMap(
+        __TS__ArrayFilter(
+            __TS__StringSplit(
+                dataToString(data),
+                ","
+            ),
+            isDataNotBlank
+        ),
+        function(____, data) return dataToNumber(data) end
+    )
+end
+stringsToData = function(value)
+    return table.concat(
+        __TS__ArrayMap(
+            value,
+            function(____, ____string) return stringToData(____string) end
+        ),
+        ","
+    )
+end
+dataToStrings = function(data)
+    return __TS__ArrayMap(
+        __TS__ArrayFilter(
+            __TS__StringSplit(
+                dataToString(data),
+                ","
+            ),
+            isDataNotBlank
+        ),
+        function(____, data) return dataToString(data) end
+    )
+end
+objectDataEntryIdsToData = function(value)
+    return table.concat(
+        __TS__ArrayMap(
+            value,
+            function(____, objectDataEntryId) return objectDataEntryIdToData(objectDataEntryId) end
+        ),
+        ","
+    )
+end
+dataToObjectDataEntryIds = function(data)
+    return __TS__ArrayMap(
+        __TS__ArrayFilter(
+            __TS__StringSplit(
+                dataToString(data),
+                ","
+            ),
+            isDataNotBlank
+        ),
+        function(____, data) return dataToObjectDataEntryId(data) end
+    )
+end
+isDataNotBlank = function(self, data)
+    return data:isNotBlank() and data ~= "_"
+end
+return ____exports

package/engine/object-data/utility/object-data-entry-id-generator.d.ts

@@ -0,0 +1,6 @@
+/** @noSelfInFile */
+export declare class ObjectDataEntryIdGenerator {
+    private id;
+    constructor(firstId: number);
+    next(): number;
+}

package/engine/object-data/utility/object-data-entry-id-generator.lua

@@ -0,0 +1,63 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local function nextValidChar(char)
+    if char < 48 or char > 126 then
+        return 48
+    end
+    if char == 57 then
+        return 97
+    end
+    return char + 1
+end
+local function isIdOccupied(id)
+    if currentMap ~= nil then
+        for ____, objectData in pairs(currentMap.objects) do
+            if objectData:getObject(id) ~= nil then
+                return true
+            end
+        end
+    end
+    return false
+end
+local function nextIdFrom(id)
+    local b1, b2, b3, b4 = string.byte(
+        util.id2s(id),
+        1,
+        4
+    )
+    while isIdOccupied(string.char(b1, b2, b3, b4)) do
+        if b4 < 126 then
+            b4 = nextValidChar(b4)
+        elseif b3 < 126 then
+            b4 = 48
+            b3 = nextValidChar(b3)
+        elseif b2 < 126 then
+            b4 = 48
+            b3 = 48
+            b2 = nextValidChar(b2)
+        elseif b1 < 126 then
+            b4 = 48
+            b3 = 48
+            b2 = 48
+            b1 = nextValidChar(b1)
+        else
+            return nil
+        end
+    end
+    return util.s2id(string.char(b1, b2, b3, b4))
+end
+____exports.ObjectDataEntryIdGenerator = __TS__Class()
+local ObjectDataEntryIdGenerator = ____exports.ObjectDataEntryIdGenerator
+ObjectDataEntryIdGenerator.name = "ObjectDataEntryIdGenerator"
+function ObjectDataEntryIdGenerator.prototype.____constructor(self, firstId)
+    self.id = firstId
+end
+function ObjectDataEntryIdGenerator.prototype.next(self)
+    local id = checkNotNull(nextIdFrom(self.id))
+    self.id = id
+    return id
+end
+return ____exports

package/engine/object-data/utility/order-type-string-id-factory.d.ts

@@ -0,0 +1,9 @@
+/** @noSelfInFile */
+import { TargetingType } from "../auxiliary/targeting-type";
+export declare class OrderTypeStringIdFactory {
+    private positionByTargetingType;
+    private recycleQueueByTargetingType;
+    next(targetingType: TargetingType): string;
+    recycle(orderString: string): void;
+}
+export declare const orderTypeStringIdFactory: OrderTypeStringIdFactory;