@siredvin/typed-peripheral-base 0.2.0

package/base.lua

@@ -0,0 +1,244 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ArrayFind = ____lualib.__TS__ArrayFind
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local __TS__ArrayPushArray = ____lualib.__TS__ArrayPushArray
+local ____exports = {}
+____exports.PeripheralDiscovery = __TS__Class()
+local PeripheralDiscovery = ____exports.PeripheralDiscovery
+PeripheralDiscovery.name = "PeripheralDiscovery"
+function PeripheralDiscovery.prototype.____constructor(self)
+end
+____exports.PeripheralDiscoveryByName = __TS__Class()
+local PeripheralDiscoveryByName = ____exports.PeripheralDiscoveryByName
+PeripheralDiscoveryByName.name = "PeripheralDiscoveryByName"
+__TS__ClassExtends(PeripheralDiscoveryByName, ____exports.PeripheralDiscovery)
+function PeripheralDiscoveryByName.prototype.____constructor(self, provider, name)
+    PeripheralDiscoveryByName.____super.prototype.____constructor(self)
+    self.provider = provider
+    self.name = name
+end
+function PeripheralDiscoveryByName.prototype.discover(self)
+    return {self.provider:wrap(self.name)}
+end
+____exports.PeripheralDiscoveryByNames = __TS__Class()
+local PeripheralDiscoveryByNames = ____exports.PeripheralDiscoveryByNames
+PeripheralDiscoveryByNames.name = "PeripheralDiscoveryByNames"
+__TS__ClassExtends(PeripheralDiscoveryByNames, ____exports.PeripheralDiscovery)
+function PeripheralDiscoveryByNames.prototype.____constructor(self, provider, ...)
+    local names = {...}
+    PeripheralDiscoveryByNames.____super.prototype.____constructor(self)
+    self.provider = provider
+    self.names = names
+end
+function PeripheralDiscoveryByNames.prototype.discover(self)
+    local result = {}
+    for ____, name in ipairs(self.names) do
+        result[#result + 1] = self.provider:wrap(name)
+    end
+    return result
+end
+____exports.PeripheralDiscoveryByType = __TS__Class()
+local PeripheralDiscoveryByType = ____exports.PeripheralDiscoveryByType
+PeripheralDiscoveryByType.name = "PeripheralDiscoveryByType"
+__TS__ClassExtends(PeripheralDiscoveryByType, ____exports.PeripheralDiscovery)
+function PeripheralDiscoveryByType.prototype.____constructor(self, provider, ____type)
+    PeripheralDiscoveryByType.____super.prototype.____constructor(self)
+    self.provider = provider
+    self.type = ____type
+end
+function PeripheralDiscoveryByType.prototype.discover(self)
+    return self.provider:collect(self.type)
+end
+____exports.PeripheralDiscoveryByTypePattern = __TS__Class()
+local PeripheralDiscoveryByTypePattern = ____exports.PeripheralDiscoveryByTypePattern
+PeripheralDiscoveryByTypePattern.name = "PeripheralDiscoveryByTypePattern"
+__TS__ClassExtends(PeripheralDiscoveryByTypePattern, ____exports.PeripheralDiscovery)
+function PeripheralDiscoveryByTypePattern.prototype.____constructor(self, pattern)
+    PeripheralDiscoveryByTypePattern.____super.prototype.____constructor(self)
+    self.pattern = pattern
+end
+function PeripheralDiscoveryByTypePattern.prototype.discover(self)
+    local peripheralNames = peripheral.getNames()
+    local purifiedPattern = ("^" .. (string.gsub((string.gsub(self.pattern, "*", ".*")), "-", "%%-"))) .. "$"
+    return __TS__ArrayMap(
+        __TS__ArrayFilter(
+            peripheralNames,
+            function(____, peripheralName)
+                local peripheralTypes = {peripheral.getType(peripheralName)}
+                local matchedType = __TS__ArrayFind(
+                    peripheralTypes,
+                    function(____, value)
+                        local result = {string.find(value, purifiedPattern)}
+                        return result[1] ~= nil
+                    end
+                )
+                return matchedType ~= nil
+            end
+        ),
+        function(____, peripheralName) return peripheral.wrap(peripheralName) end
+    )
+end
+____exports.MultiplePeripheralDiscovery = __TS__Class()
+local MultiplePeripheralDiscovery = ____exports.MultiplePeripheralDiscovery
+MultiplePeripheralDiscovery.name = "MultiplePeripheralDiscovery"
+__TS__ClassExtends(MultiplePeripheralDiscovery, ____exports.PeripheralDiscovery)
+function MultiplePeripheralDiscovery.prototype.____constructor(self, ...)
+    local discoveries = {...}
+    MultiplePeripheralDiscovery.____super.prototype.____constructor(self)
+    self.discoveries = discoveries
+end
+function MultiplePeripheralDiscovery.prototype.discover(self)
+    local baseResult = {}
+    for ____, discovery in ipairs(self.discoveries) do
+        __TS__ArrayPushArray(
+            baseResult,
+            discovery:discover()
+        )
+    end
+    return baseResult
+end
+____exports.IPeripheralProvider = __TS__Class()
+local IPeripheralProvider = ____exports.IPeripheralProvider
+IPeripheralProvider.name = "IPeripheralProvider"
+function IPeripheralProvider.prototype.____constructor(self, peripheral_type, dummy_constructor)
+    if dummy_constructor == nil then
+        dummy_constructor = function() return nil end
+    end
+    self.peripheral_type = peripheral_type
+    self.dummy_constructor = dummy_constructor
+end
+function IPeripheralProvider.prototype.find(self, derrefed_type)
+    local ____temp_0
+    if derrefed_type == nil then
+        ____temp_0 = self.peripheral_type
+    else
+        ____temp_0 = derrefed_type
+    end
+    local seached_type = ____temp_0
+    local any_peripheral = (peripheral.find(seached_type))
+    if any_peripheral ~= nil then
+        return any_peripheral
+    end
+    if settings.get("dark_toolkit.allow_dummy", "True") == "True" then
+        return self:dummy_constructor()
+    end
+    return nil
+end
+function IPeripheralProvider.prototype.searchByType(self, pattern, derrefed_type)
+    local targetedPeripherals = self:collect(derrefed_type)
+    local purifiedPattern = ("^" .. (string.gsub((string.gsub(pattern, "*", ".*")), "-", "%%-"))) .. "$"
+    if #targetedPeripherals == 0 then
+        return
+    end
+    return __TS__ArrayFilter(
+        targetedPeripherals,
+        function(____, p)
+            local peripheralTypes = {peripheral.getType(p)}
+            local matchedType = __TS__ArrayFind(
+                peripheralTypes,
+                function(____, value)
+                    local result = {string.find(value, purifiedPattern)}
+                    return result[1] ~= nil
+                end
+            )
+            print(
+                "peripheral",
+                peripheral.getName(p),
+                "is",
+                matchedType,
+                "for",
+                purifiedPattern
+            )
+            return matchedType ~= nil
+        end
+    )
+end
+function IPeripheralProvider.prototype.stubbornFindOrThrow(self, attemps, derrefed_type)
+    if attemps == nil then
+        attemps = 5
+    end
+    for _ = 1, attemps do
+        local per = self:find(derrefed_type)
+        if per == nil then
+            os.sleep(2)
+        else
+            return per
+        end
+    end
+    error("Cannot find peripheral " .. (derrefed_type or self.peripheral_type), 0)
+end
+function IPeripheralProvider.prototype.findOrThrow(self, derrefed_type)
+    local per = self:find(derrefed_type)
+    if per == nil then
+        error("Cannot find peripheral " .. (derrefed_type or self.peripheral_type), 0)
+    end
+    return per
+end
+function IPeripheralProvider.prototype.searchOneByType(self, pattern, derrefed_type)
+    local targetedPeripherals = self:searchByType(pattern, derrefed_type)
+    if #targetedPeripherals == 0 then
+        error("Cannot find peripheral " .. (derrefed_type or self.peripheral_type), 0)
+    end
+    if #targetedPeripherals > 1 then
+        local names = table.concat(
+            __TS__ArrayMap(
+                targetedPeripherals,
+                function(____, p) return peripheral.getName(p) end
+            ),
+            ";"
+        )
+        error((((("Too many peripherals was found " .. (derrefed_type or self.peripheral_type)) .. " even with pattern ") .. pattern) .. " this peripherals was found: ") .. names, 0)
+    end
+    return targetedPeripherals[1]
+end
+function IPeripheralProvider.prototype.collect(self, derrefed_type)
+    local ____temp_1
+    if derrefed_type == nil then
+        ____temp_1 = self.peripheral_type
+    else
+        ____temp_1 = derrefed_type
+    end
+    local seached_type = ____temp_1
+    local any_peripherals = {peripheral.find(seached_type)}
+    if #any_peripherals == 0 then
+        return {}
+    end
+    return __TS__ArrayMap(
+        any_peripherals,
+        function(____, v) return v end
+    )
+end
+function IPeripheralProvider.prototype.wrapValidate(self, name)
+    local candidate = peripheral.wrap(name)
+    if candidate == nil then
+        return nil
+    end
+    local types = {peripheral.getType(candidate)}
+    for ____, ____type in ipairs(types) do
+        if ____type == self.peripheral_type then
+            return candidate
+        end
+    end
+    return nil
+end
+function IPeripheralProvider.prototype.wrap(self, name)
+    if type(name) == "table" then
+        local periphs = {}
+        for ____, single_name in ipairs(name) do
+            local candidate = peripheral.wrap(single_name)
+            if candidate ~= nil then
+                periphs[#periphs + 1] = candidate
+            end
+        end
+        return periphs
+    end
+    local wrapped = peripheral.wrap(name)
+    if wrapped == nil then
+        return nil
+    end
+    return wrapped
+end
+return ____exports

package/base.ts

@@ -0,0 +1,262 @@
+import { side } from "cc.completion";
+import { base } from "tstl";
+import { FluidStorageAPI } from "./apis/fluid_storage";
+
+export type NamePredicate = (name: string) => boolean;
+
+export type ShortItemDetail = {
+    count: number;
+    name: string;
+};
+
+export type ExtendedItemDetail = ItemDetail & {
+    gtceu?: {
+        craftingUses?: number;
+        generalUses?: number;
+        maxUses?: number;
+        circuitConfiguration?: number;
+    };
+};
+
+export type FluidDetail = {
+    amount: number;
+    name: string;
+};
+
+export type PreciseFluidDetail = FluidDetail & {
+    precise_amount: number;
+};
+
+export type ElementPredicate<T> = (info: T) => boolean;
+export type ItemPredicate = (info: ItemDetail) => boolean;
+export type FluidPredicate = (info: FluidStorageAPI) => boolean;
+export type CombinedPredicate = (info: ItemDetail | FluidDetail) => boolean;
+export type PeripheralPredicate = (info: IPeripheral) => boolean;
+
+export abstract class PeripheralDiscovery<T extends IPeripheral> {
+    abstract discover(): T[];
+}
+
+export class PeripheralDiscoveryByName<
+    T extends IPeripheral
+> extends PeripheralDiscovery<T> {
+    constructor(
+        readonly provider: IPeripheralProvider<T>,
+        readonly name: string
+    ) {
+        super();
+    }
+    discover(): T[] {
+        return [this.provider.wrap(this.name)];
+    }
+}
+
+export class PeripheralDiscoveryByNames<
+    T extends IPeripheral
+> extends PeripheralDiscovery<T> {
+    private names: string[];
+    constructor(readonly provider: IPeripheralProvider<T>, ...names: string[]) {
+        super();
+        this.names = names;
+    }
+
+    discover(): T[] {
+        const result = [];
+        for (let name of this.names) {
+            result.push(this.provider.wrap(name));
+        }
+        return result;
+    }
+}
+
+export class PeripheralDiscoveryByType<
+    T extends IPeripheral
+> extends PeripheralDiscovery<T> {
+    constructor(
+        readonly provider: IPeripheralProvider<T>,
+        readonly type: string
+    ) {
+        super();
+    }
+
+    discover(): T[] {
+        return this.provider.collect(this.type);
+    }
+}
+
+export class PeripheralDiscoveryByTypePattern<
+    T extends IPeripheral
+> extends PeripheralDiscovery<T> {
+    constructor(readonly pattern: string) {
+        super();
+    }
+    discover(): T[] {
+        const peripheralNames = peripheral.getNames();
+        const purifiedPattern =
+            "^" +
+            string.gsub(
+                string.gsub(this.pattern, "*", ".*")[0],
+                "-",
+                "%%-"
+            )[0] +
+            "$";
+
+        return peripheralNames
+            .filter((peripheralName) => {
+                const peripheralTypes = peripheral.getType(peripheralName);
+                const matchedType = peripheralTypes.find((value) => {
+                    let result = string.find(value, purifiedPattern);
+                    return result[0] != null;
+                });
+                return matchedType !== undefined;
+            })
+            .map((peripheralName) => peripheral.wrap(peripheralName)) as T[];
+    }
+}
+
+export class MultiplePeripheralDiscovery<
+    T extends IPeripheral
+> extends PeripheralDiscovery<T> {
+    private discoveries: PeripheralDiscovery<T>[];
+    constructor(...discoveries: PeripheralDiscovery<T>[]) {
+        super();
+        this.discoveries = discoveries;
+    }
+
+    discover(): T[] {
+        const baseResult = [];
+        for (let discovery of this.discoveries) {
+            baseResult.push(...discovery.discover());
+        }
+        return baseResult;
+    }
+}
+
+export class IPeripheralProvider<Type extends IPeripheral> {
+    constructor(
+        readonly peripheral_type: string,
+        readonly dummy_constructor: () => Type | null = () => null
+    ) {}
+
+    find(derrefed_type?: string): Type | null {
+        let seached_type =
+            derrefed_type == null ? this.peripheral_type : derrefed_type;
+        const any_peripheral = peripheral.find(seached_type)[0];
+        if (any_peripheral != null) {
+            return any_peripheral as Type;
+        }
+        if (settings.get("dark_toolkit.allow_dummy", "True") == "True") {
+            return this.dummy_constructor();
+        }
+        return null;
+    }
+
+    searchByType(pattern: string, derrefed_type?: string): Array<Type> {
+        const targetedPeripherals = this.collect(derrefed_type);
+        const purifiedPattern =
+            "^" +
+            string.gsub(string.gsub(pattern, "*", ".*")[0], "-", "%%-")[0] +
+            "$";
+        if (targetedPeripherals.length == 0) return;
+        return targetedPeripherals.filter((p) => {
+            const peripheralTypes = peripheral.getType(p);
+            const matchedType = peripheralTypes.find((value) => {
+                let result = string.find(value, purifiedPattern);
+                return result[0] != null;
+            });
+            print(
+                "peripheral",
+                peripheral.getName(p),
+                "is",
+                matchedType,
+                "for",
+                purifiedPattern
+            );
+            return matchedType !== undefined;
+        });
+    }
+
+    stubbornFindOrThrow(attemps: number = 5, derrefed_type?: string): Type {
+        for (let _ of $range(1, attemps)) {
+            let per = this.find(derrefed_type);
+            if (per == null) {
+                os.sleep(2);
+            } else {
+                return per;
+            }
+        }
+        throw (
+            "Cannot find peripheral " + (derrefed_type || this.peripheral_type)
+        );
+    }
+
+    findOrThrow(derrefed_type?: string): Type {
+        let per = this.find(derrefed_type);
+        if (per == null) {
+            throw (
+                "Cannot find peripheral " +
+                (derrefed_type || this.peripheral_type)
+            );
+        }
+        return per;
+    }
+
+    searchOneByType(pattern: string, derrefed_type?: string): Type {
+        let targetedPeripherals = this.searchByType(pattern, derrefed_type);
+        if (targetedPeripherals.length == 0) {
+            throw (
+                "Cannot find peripheral " +
+                (derrefed_type || this.peripheral_type)
+            );
+        }
+        if (targetedPeripherals.length > 1) {
+            const names = targetedPeripherals
+                .map((p) => peripheral.getName(p))
+                .join(";");
+            throw (
+                "Too many peripherals was found " +
+                (derrefed_type || this.peripheral_type) +
+                " even with pattern " +
+                pattern +
+                " this peripherals was found: " +
+                names
+            );
+        }
+        return targetedPeripherals[0];
+    }
+
+    collect(derrefed_type?: string): Array<Type> {
+        let seached_type =
+            derrefed_type == null ? this.peripheral_type : derrefed_type;
+        const any_peripherals = peripheral.find(seached_type);
+        if (any_peripherals.length == 0) return [];
+        return any_peripherals.map((v) => v as Type);
+    }
+
+    wrapValidate(name: string): Type | null {
+        const candidate = peripheral.wrap(name) as Type;
+        if (candidate == null) return null;
+        const types = peripheral.getType(candidate);
+        for (let type of types) {
+            if (type == this.peripheral_type) return candidate;
+        }
+        return null;
+    }
+
+    wrap(name: string): Type | null;
+    wrap(name: string[]): Type[];
+
+    wrap(name: string | string[]): Type | null | Type[] {
+        if (type(name) == "table") {
+            const periphs = [];
+            for (let single_name of name as string[]) {
+                const candidate = peripheral.wrap(single_name) as Type;
+                if (candidate != null) periphs.push(candidate);
+            }
+            return periphs;
+        }
+        const wrapped = peripheral.wrap(name as string);
+        if (wrapped == null) return null;
+        return wrapped as Type;
+    }
+}

package/lualib_bundle.lua

@@ -0,0 +1,79 @@
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+local function __TS__ClassExtends(target, base)
+    target.____super = base
+    local staticMetatable = setmetatable({__index = base}, base)
+    setmetatable(target, staticMetatable)
+    local baseMetatable = getmetatable(base)
+    if baseMetatable then
+        if type(baseMetatable.__index) == "function" then
+            staticMetatable.__index = baseMetatable.__index
+        end
+        if type(baseMetatable.__newindex) == "function" then
+            staticMetatable.__newindex = baseMetatable.__newindex
+        end
+    end
+    setmetatable(target.prototype, base.prototype)
+    if type(base.prototype.__index) == "function" then
+        target.prototype.__index = base.prototype.__index
+    end
+    if type(base.prototype.__newindex) == "function" then
+        target.prototype.__newindex = base.prototype.__newindex
+    end
+    if type(base.prototype.__tostring) == "function" then
+        target.prototype.__tostring = base.prototype.__tostring
+    end
+end
+
+local function __TS__ArrayFind(self, predicate, thisArg)
+    for i = 1, #self do
+        local elem = self[i]
+        if predicate(thisArg, elem, i - 1, self) then
+            return elem
+        end
+    end
+    return nil
+end
+
+local function __TS__ArrayFilter(self, callbackfn, thisArg)
+    local result = {}
+    local len = 0
+    for i = 1, #self do
+        if callbackfn(thisArg, self[i], i - 1, self) then
+            len = len + 1
+            result[len] = self[i]
+        end
+    end
+    return result
+end
+
+local function __TS__ArrayMap(self, callbackfn, thisArg)
+    local result = {}
+    for i = 1, #self do
+        result[i] = callbackfn(thisArg, self[i], i - 1, self)
+    end
+    return result
+end
+
+local function __TS__ArrayPushArray(self, items)
+    local len = #self
+    for i = 1, #items do
+        len = len + 1
+        self[len] = items[i]
+    end
+    return len
+end
+
+return {
+  __TS__Class = __TS__Class,
+  __TS__ClassExtends = __TS__ClassExtends,
+  __TS__ArrayFind = __TS__ArrayFind,
+  __TS__ArrayFilter = __TS__ArrayFilter,
+  __TS__ArrayMap = __TS__ArrayMap,
+  __TS__ArrayPushArray = __TS__ArrayPushArray
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@siredvin/typed-peripheral-base",
+    "version": "0.2.0",
+    "description": "Typed peripheral library for my CC:T related projects",
+    "files": [
+        "./*.ts",
+        "./*.lua"
+    ],
+    "author": "SirEdvin",
+    "license": "MIT",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "build": "tstl",
+        "clean": "rm -f *.lua",
+        "lint": "eslint . --ext .ts,.js",
+        "depcheck": "depcheck"
+    },
+    "devDependencies": {
+        "@siredvin/cc-types": "1.1.0",
+        "@siredvin/craftos-types": "1.2.0",
+        "@siredvin/api-types": "1.1.0",
+        "@jackmacwindows/lua-types": "^2.13.1",
+        "typescript-to-lua": "*",
+        "typescript": "*",
+        "@siredvin/cc-events": "0.2.0"
+    },
+    "nx": {
+        "targets": {
+            "lint": {
+                "executor": "@nx/linter:eslint",
+                "outputs": [
+                    "{options.outputFile}"
+                ],
+                "options": {
+                    "lintFilePatterns": [
+                        "packages/typed-peripheral/**/*.{ts,tsx,js,jsx}"
+                    ]
+                }
+            },
+            "depcheck": {
+                "executor": "nx:run-commands",
+                "options": {
+                    "command": "depcheck",
+                    "cwd": "packages/typed-peripheral"
+                }
+            }
+        }
+    }
+}