@skyrim-platform/jcontainers/JValue.js

TypeScript library for the JContainers Skyrim modding utility

/*
==============================================
Typescript definitions for v4.2.1
==============================================

This file was automatically generated by Papyrus-2-Typescript.exe
https://github.com/CarlosLeyvaAyala/Papyrus-2-Typescript

The program has no way to know the intention of the humans that made
the scripts, so it's always advisable to manually check all generated
files to make sure everything is declared as it should.

Take note the program assumes this script exists in some subfolder
to the folder where `skyrimPlatform.ts` is found, otherwise you'll get
"Cannot find module..." type of errors.

If you want to have this script in some other place, just change the
relative path of each `import`.
*/
import * as sp from "skyrimPlatform";
/** Common functionality, shared by JArray, JMap, JFormMap, JIntMap */
var sn = sp.JValue;
/** Most call entries made to JC will be logged. Heavy traffic, by default is disabled.
    Not thread safe for multiple users (though harmless). */
export var enableAPILog = function (arg0) { return sn.enableAPILog(arg0); };
/** --- Lifetime management functionality.
    Read this https://github.com/ryobg/JContainers/wiki/Lifetime-Management before using any of lifetime management functions
    
    Retains and returns the object. */
export var retain = function (object, tag) {
    if (tag === void 0) { tag = ""; }
    return sn.retain(object, tag);
};
/** Releases the object and returns zero, so you can release and nullify with one line of code: object = JValue.release(object) */
export var release = function (object) { return sn.release(object); };
/** Just a union of retain-release calls. Releases @previousObject, retains and returns @newObject. */
export var releaseAndRetain = function (previousObject, newObject, tag) {
    if (tag === void 0) { tag = ""; }
    return sn.releaseAndRetain(previousObject, newObject, tag);
};
/** Releases all objects tagged with @tag.
    Internally invokes JValue.release on each object same amount of times it has been retained. */
export var releaseObjectsWithTag = function (tag) { return sn.releaseObjectsWithTag(tag); };
/** Minimizes the time JC temporarily owns the object, returns the object.
    By using this function you help JC to delete unused objects as soon as possible.
    Has zero effect if the object is being retained or if another object contains/references it. */
export var zeroLifetime = function (object) { return sn.zeroLifetime(object); };
/** Handly for temporary objects (objects with no owners) - the pool 'locationName' owns any amount of objects, preventing their destuction, extends lifetime.
    Do not forget to clean the pool later! Typical use:
    int jTempMap = JValue.addToPool(JMap.object(), "uniquePoolName")
    int jKeys = JValue.addToPool(JMap.allKeys(someJMap), "uniquePoolName")
    and anywhere later:
    JValue.cleanPool("uniquePoolName") */
export var addToPool = function (object, poolName) { return sn.addToPool(object, poolName); };
export var cleanPool = function (poolName) { return sn.cleanPool(poolName); };
/** --- Mics. functionality
    
    Returns shallow copy (won't copy child objects) */
export var shallowCopy = function (object) { return sn.shallowCopy(object); };
/** Returns deep copy */
export var deepCopy = function (object) { return sn.deepCopy(object); };
/** Tests whether given object identifier is not the null object.
    Note that many other API functions already check that too. */
export var isExists = function (object) { return sn.isExists(object); };
/** Returns true if the object is map, array or formmap container */
export var isArray = function (object) { return sn.isArray(object); };
export var isMap = function (object) { return sn.isMap(object); };
export var isFormMap = function (object) { return sn.isFormMap(object); };
export var isIntegerMap = function (object) { return sn.isIntegerMap(object); };
/** Returns true, if the container is empty */
export var empty = function (object) { return sn.empty(object); };
/** Returns amount of items in the container */
export var count = function (object) { return sn.count(object); };
/** Removes all items from the container */
export var clear = function (object) { return sn.clear(object); };
/** JSON serialization/deserialization:
    
    Creates and returns a new container object containing contents of JSON file */
export var readFromFile = function (filePath) { return sn.readFromFile(filePath); };
/** Parses JSON files in a directory (non recursive) and returns JMap containing {filename, container-object} pairs.
    Note: by default it does not filter files by extension and will try to parse everything */
export var readFromDirectory = function (directoryPath, extension) {
    if (extension === void 0) { extension = ""; }
    return sn.readFromDirectory(directoryPath, extension);
};
/** Creates a new container object using given JSON string-prototype */
export var objectFromPrototype = function (prototype) { return sn.objectFromPrototype(prototype); };
/** Writes the object into JSON file */
export var writeToFile = function (object, filePath) { return sn.writeToFile(object, filePath); };
/** Returns type of resolved value. 0 - no value, 1 - none, 2 - int, 3 - float, 4 - form, 5 - object, 6 - string */
export var solvedValueType = function (object, path) { return sn.solvedValueType(object, path); };
/** Path resolving:
    
    Returns true, if it's possible to resolve given path, i.e. if it's possible to retrieve the value at the path.
    For ex. JValue.hasPath(container, ".player.health") will test whether @container structure close to this one - {'player': {'health': health_value}} */
export var hasPath = function (object, path) { return sn.hasPath(object, path); };
/** Attempts to retrieve value at given path. If fails, returns @default value */
export var solveFlt = function (object, path, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0.0; }
    return sn.solveFlt(object, path, defaultVal);
};
export var solveInt = function (object, path, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0; }
    return sn.solveInt(object, path, defaultVal);
};
export var solveStr = function (object, path, defaultVal) {
    if (defaultVal === void 0) { defaultVal = ""; }
    return sn.solveStr(object, path, defaultVal);
};
export var solveObj = function (object, path, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0; }
    return sn.solveObj(object, path, defaultVal);
};
export var solveForm = function (object, path, defaultVal) {
    if (defaultVal === void 0) { defaultVal = null; }
    return sn.solveForm(object, path, defaultVal);
};
/** Attempts to assign the value. If @createMissingKeys is False it may fail to assign - if no such path exist.
    With 'createMissingKeys=true' it creates any missing path element: solveIntSetter(map, ".keyA.keyB", 10, true) on empty JMap creates {keyA: {keyB: 10}} structure */
export var solveFltSetter = function (object, path, value, createMissingKeys) {
    if (createMissingKeys === void 0) { createMissingKeys = false; }
    return sn.solveFltSetter(object, path, value, createMissingKeys);
};
export var solveIntSetter = function (object, path, value, createMissingKeys) {
    if (createMissingKeys === void 0) { createMissingKeys = false; }
    return sn.solveIntSetter(object, path, value, createMissingKeys);
};
export var solveStrSetter = function (object, path, value, createMissingKeys) {
    if (createMissingKeys === void 0) { createMissingKeys = false; }
    return sn.solveStrSetter(object, path, value, createMissingKeys);
};
export var solveObjSetter = function (object, path, value, createMissingKeys) {
    if (createMissingKeys === void 0) { createMissingKeys = false; }
    return sn.solveObjSetter(object, path, value, createMissingKeys);
};
export var solveFormSetter = function (object, path, value, createMissingKeys) {
    if (createMissingKeys === void 0) { createMissingKeys = false; }
    return sn.solveFormSetter(object, path, value, createMissingKeys);
};
/** Evaluates piece of lua code. Lua support is experimental */
export var evalLuaFlt = function (object, luaCode, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0.0; }
    return sn.evalLuaFlt(object, luaCode, defaultVal);
};
export var evalLuaInt = function (object, luaCode, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0; }
    return sn.evalLuaInt(object, luaCode, defaultVal);
};
export var evalLuaStr = function (object, luaCode, defaultVal) {
    if (defaultVal === void 0) { defaultVal = ""; }
    return sn.evalLuaStr(object, luaCode, defaultVal);
};
export var evalLuaObj = function (object, luaCode, defaultVal) {
    if (defaultVal === void 0) { defaultVal = 0; }
    return sn.evalLuaObj(object, luaCode, defaultVal);
};
export var evalLuaForm = function (object, luaCode, defaultVal) {
    if (defaultVal === void 0) { defaultVal = null; }
    return sn.evalLuaForm(object, luaCode, defaultVal);
};