qpremake 1.5.3 → 1.6.3

package/lib/types/misc.d.ts

@@ -1,97 +0,0 @@
-import type { playerTypeID } from "../data/zoneRegistry";
-export type hexChars = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F';
-export type hexChars2 = `${hexChars}${hexChars}`;
-export type hexString3 = `#${hexChars}${hexChars2}`;
-export type hexString4 = `#${hexChars2}${hexChars2}`;
-export type hexString6 = string;
-export declare enum damageType {
-    "physical" = 0,
-    "magic" = 1
-}
-export type typeSigatureSimple = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-export type typeSigatureArray = `${typeSigatureSimple}[]` | "any[]" | "empty[]";
-export type typeSignature = typeSigatureSimple | typeSigatureArray;
-export type singleTypedArray<T> = T[];
-export type safeSimpleTypes = number | string | boolean;
-export type Fn<Args extends any[], Ret> = (...args: Args) => Ret;
-export type Fn_2<Args1 extends any[], Args2 extends any[], Ret> = (...args1: Args1) => (...args2: Args2) => Ret;
-export type Fn_3<Args1 extends any[], Args2 extends any[], Args3 extends any[], Ret> = (...args1: Args1) => (...args2: Args2) => (...args3: Args3) => Ret;
-export type Fn_4<Args1 extends any[], Args2 extends any[], Args3 extends any[], Args4 extends any[], Ret> = (...a1: Args1) => (...a2: Args2) => (...a3: Args3) => (...a4: Args4) => Ret;
-export type Fn_5<Args1 extends any[], Args2 extends any[], Args3 extends any[], Args4 extends any[], Args5 extends any[], Ret> = (...a1: Args1) => (...a2: Args2) => (...a3: Args3) => (...a4: Args4) => (...a5: Args5) => Ret;
-export type lambda_number = Array<0>;
-export type precursor<T extends lambda_number> = T extends [0, ...infer Tail] ? Tail : never;
-export type successor<T extends lambda_number> = [0, ...T];
-export type lambda_number_monster = NumToLambda<50>;
-export type lambda_number_monster_num = LambdaToNum<lambda_number_monster>;
-export type Fn_any<Ret, recurLevel extends lambda_number> = (...args: any) => recurLevel extends [] ? Ret : Fn_any<Ret, precursor<recurLevel>>;
-export type ExtractReturn_any<T extends Fn<any, any>, maxRecurLevel extends lambda_number = lambda_number_monster> = T extends Fn_any<infer A, maxRecurLevel> ? A : maxRecurLevel extends [] ? never : ExtractReturn_any<T, precursor<maxRecurLevel>>;
-export type ExtractArgs<T> = T extends Fn<infer A, any> ? A : never;
-export type ExtractReturn<T> = T extends Fn<any, infer R> ? R : never;
-export type WritableKeys<T> = {
-    [K in keyof T]-?: IfEquals<{
-        [Q in K]: T[K];
-    }, {
-        -readonly [Q in K]: T[K];
-    }, K>;
-}[keyof T];
-export type Tuple_any<T, len extends number = lambda_number_monster_num, cull extends T[] = [], len_lambda extends lambda_number = NumToLambda<len>> = number extends len ? T[] : len_lambda extends [] ? cull : Tuple_any<T, len, [T, ...cull], precursor<len_lambda>>;
-export type LenInLambda<T extends any[]> = NumToLambda<T["length"]>;
-export type lambdaArr<End extends lambda_number = lambda_number_monster, Start extends lambda_number = [], cull extends lambda_number[] = []> = End extends Start ? [Start, ...cull] : lambdaArr<precursor<End>, Start, [End, ...cull]>;
-export type Add<A extends lambda_number, B extends lambda_number> = [...A, ...B];
-export type Sub<A extends lambda_number, B extends lambda_number> = A extends [...B, ...infer K] ? K : [];
-export type Mul<A extends lambda_number, B extends lambda_number> = A extends [] ? [] : B extends [] ? [] : [
-    ...Mul<precursor<A>, B>,
-    ...B
-];
-export type Div<A extends lambda_number, B extends lambda_number, C extends lambda_number = []> = B extends 0 ? never : A extends [] ? [] : isLtr<A, B, C, Div<Sub<A, B>, B, [0, ...C]>>;
-export type Mod<A extends lambda_number, B extends lambda_number> = B extends 0 ? never : A extends [] ? [] : isLtr<A, B, A, Mod<Sub<A, B>, B>>;
-export type Sum<T extends lambda_number[], cull extends lambda_number = [], T_head extends lambda_number = T extends [infer Head, ...any[]] ? Head : [], T_tail extends lambda_number[] = T extends [any, ...infer Tail] ? Tail : []> = T extends [] ? cull : Sum<T_tail, Add<cull, T_head>>;
-export type isGtr<A extends lambda_number, B extends lambda_number, resTrue = true, resFalse = false> = isLtr<B, A, resTrue, resFalse>;
-export type isLtr<A extends lambda_number, B extends lambda_number, resTrue = true, resFalse = false> = Sub<A, B> extends never ? resTrue : resFalse;
-export type isLeq<A extends lambda_number, B extends lambda_number, resTrue = true, resFalse = false> = A extends B ? resTrue : isLtr<A, B, resTrue, resFalse>;
-export type isGeq<A extends lambda_number, B extends lambda_number, resTrue = true, resFalse = false> = A extends B ? resTrue : isGtr<A, B, resTrue, resFalse>;
-export type NumToLambda<T extends number, cull extends lambda_number = []> = LambdaToNum<cull> extends T ? cull : NumToLambda<T, [0, ...cull]>;
-export type LambdaToNum<T extends lambda_number> = T["length"];
-export type sliceHead<T extends Array<any>, Head extends Array<any>> = T extends [...Head, ...infer Tail] ? Tail : never;
-export type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? A : B;
-export type OnlyWritableProps<T> = Pick<T, WritableKeys<T>>;
-export type Position_like = {
-    readonly x: number;
-    readonly y: number;
-    readonly zoneID: number;
-    flat(): ReadonlyArray<number>;
-};
-export type Player_specific = {
-    playerIndex: number;
-    playerType: playerTypeID;
-};
-export type HasTypesArr = {
-    types: ReadonlyArray<number>;
-};
-export type id_able = {
-    id: string | number;
-};
-export type Positionable = {
-    pos: Position_like;
-};
-export type Readonly_recur<T> = T extends Fn<any, any> ? T : T extends (infer R)[] ? ReadonlyArray<Readonly_recur<R>> : T extends Map<infer K, infer V> ? ReadonlyMap<K, Readonly_recur<V>> : T extends Set<infer K> ? ReadonlySet<Readonly_recur<K>> : T extends ReadonlyArray<any> ? T : T extends ReadonlyMap<any, any> ? T : T extends ReadonlySet<any> ? T : T extends object ? {
-    readonly [K in keyof T as T[K] extends Fn<any, any> ? never : K]: Readonly_recur<T[K]>;
-} : T;
-export type Transplant<T extends Object, K extends keyof T, newType> = {
-    [K2 in keyof T as newType extends never ? never : K2]: K2 extends K ? newType : T[K2];
-};
-export type FilterKeys<T extends Object, ConditionType> = keyof {
-    [K in keyof T as T[K] extends ConditionType ? K : never]: true;
-};
-export type lastInfo<T extends any[], saved extends any[] = []> = [
-] extends T ? never : T extends [any] ? [T, saved] : T extends [infer Head, ...infer Tails] ? lastInfo<Tails, [...saved, Head]> : [T, saved];
-export type FunctionalKeys<T extends Object> = FilterKeys<T, Fn<any, any>>;
-export type UnFunctionalKeys<T extends Object> = Exclude<keyof T, FunctionalKeys<T>>;
-export type Readonly_recur_Record<K extends keyof any, V> = Readonly<Record<K, Readonly_recur<V>>>;
-export type isUnion<T, U = T> = T extends any ? [U] extends [T] ? false : true : never;
-export type notFull<T extends any[], R extends any[] = []> = T extends [infer Head, ...infer Tail] ? R | notFull<Tail, [...R, Head]> : R;
-export interface StrictGenerator<Y, R, N> extends Generator<Y, R, N> {
-    next(value: N): IteratorResult<Y, R>;
-}
-export type nestedTree<T> = T[] | nestedTree<T>[];
-export type Last<T extends any[], K extends any[] = []> = T extends K ? T[sliceHead<K, [any]>["length"]] : Last<T, [any, ...K]>;

package/lib/types/misc.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.damageType = void 0;
-var damageType;
-(function (damageType) {
-    damageType[damageType["physical"] = 0] = "physical";
-    damageType[damageType["magic"] = 1] = "magic";
-})(damageType || (exports.damageType = damageType = {}));

package/lib/types/mods/effectTextParserModule.d.ts

@@ -1,16 +0,0 @@
-import type { parseOptions } from "../abstract/parser/options";
-import { DisplayComponent } from "../abstract/parser/component";
-import moduleInputObject from "../abstract/parser/moduleInputObject";
-import type { nestedTree } from "../misc";
-export declare class ParserModule {
-    cmdName: string[];
-    requiredAttr: string[][];
-    doCheckRequiredAttr: boolean;
-    generateInputObj(cmdIndex: number, attrObj: {
-        [attr: string]: string;
-    }, children: nestedTree<DisplayComponent>): moduleInputObject | undefined;
-    private try_grab_child_text;
-    try_collapse_child_to_text(args: moduleInputObject): (string | nestedTree<DisplayComponent>[number])[];
-    isValidAttr(cmdIndex: number, attrName: string, attr: string): boolean;
-    evaluate(cmd: string, args: moduleInputObject, option: parseOptions, raw: string): nestedTree<DisplayComponent>;
-}

package/lib/types/mods/effectTextParserModule.js

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParserModule = void 0;
-const component_1 = require("../abstract/parser/component");
-const moduleInputObject_1 = __importDefault(require("../abstract/parser/moduleInputObject"));
-//abstract class
-class ParserModule {
-    constructor() {
-        this.cmdName = [];
-        this.requiredAttr = [];
-        this.doCheckRequiredAttr = false;
-    }
-    //can override, but shouldn't tbh
-    generateInputObj(cmdIndex, attrObj, children) {
-        let res = new moduleInputObject_1.default(attrObj, children);
-        if (this.doCheckRequiredAttr) {
-            if (!this.requiredAttr[cmdIndex])
-                return undefined;
-            for (let i = 0; i < this.requiredAttr[cmdIndex].length; i++) {
-                const attrName = this.requiredAttr[cmdIndex][i];
-                if (res.hasAttr(attrName)) {
-                    const attr = res.getAttr(attrName);
-                    if (this.isValidAttr(cmdIndex, attrName, attr))
-                        continue;
-                    else
-                        return undefined;
-                }
-                else
-                    return undefined;
-            }
-        }
-        return res;
-    }
-    try_grab_child_text(c) {
-        //console.log(`Children arr len: ${c.length}`)
-        if (c.length != 1)
-            return undefined;
-        if (c[0] instanceof component_1.DisplayComponent) {
-            if (c[0].id == component_1.componentID.text) {
-                return c[0].str;
-            }
-        }
-        else {
-            //console.log(`Children 0 arr len: ${c[0].length}`)
-            if (c[0].length != 1)
-                return undefined;
-            if (c[0][0] instanceof component_1.DisplayComponent) {
-                if (c[0][0].id == component_1.componentID.text) {
-                    return c[0][0].str;
-                }
-            }
-        }
-        return undefined;
-    }
-    try_collapse_child_to_text(args) {
-        const c = args.getChilren();
-        const res = [];
-        c.forEach(treeNode => {
-            const str = this.try_grab_child_text([treeNode]);
-            if (!str)
-                return res.push(treeNode);
-            if (typeof res[res.length - 1] === "string")
-                res[res.length - 1] += str;
-            else
-                res.push(str);
-        });
-        return res;
-    }
-    //may override, only triger if doCheckRequiredAttr is true
-    isValidAttr(cmdIndex, attrName, attr) {
-        return true;
-    }
-    //abstract, should override
-    evaluate(cmd, args, option, raw) {
-        return [];
-    }
-}
-exports.ParserModule = ParserModule;

package/lib/types/mods/gameModule.d.ts

@@ -1,5 +0,0 @@
-import type registryAPI from "../abstract/gameComponents/API";
-export default class GameModule {
-    constructor();
-    load(API: registryAPI): void;
-}

package/lib/types/mods/gameModule.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class GameModule {
-    constructor() { }
-    //should override, call upon load
-    load(API) { }
-}
-exports.default = GameModule;

package/lib/utils/index.d.ts

@@ -1,78 +0,0 @@
-import type { cardData_unified, patchData } from "../data/cardRegistry";
-import { type Setting } from "../types/abstract/gameComponents/settings";
-import { partitionSetting } from "../types/abstract/gameComponents/settings";
-import type { nestedTree, Player_specific, Positionable, safeSimpleTypes, typeSignature } from "../types/misc";
-type recursiveGenerator<T> = Generator<any, T | recursiveGenerator<T>, any>;
-declare class utils {
-    static toProper(str: string): string;
-    static most<T extends safeSimpleTypes>(arr: T[]): T | undefined;
-    static rng(max: number, min: number, round: boolean): number;
-    static rngArr(len: number, max: number, min: number, round: boolean): number[];
-    static rngChoice<T>(choices: T[]): T;
-    static rngArrChoice<T>(len: number, choices: T[]): T[];
-    static round(num: number, precision: number): number;
-    static clamp(num: number, max: number, min?: number): number;
-    static toSafeNumber(n?: number | boolean | string, doTruncation?: boolean): number;
-    static generateID(length?: number): string;
-    static dataIDToUniqueID(id: string, num: number, s: Setting, ...append: string[]): string;
-    static removeDuplicates(...arr: any[][]): any[];
-    static pushReadOnlyReference(arr: any[], b: Record<string, any>, prop: string): void;
-    static pushReference(arr: any[], b: Record<string, any>, prop: string): void;
-    static indexToPosition(index: number, shapeArr: ReadonlyArray<number>): number[];
-    /**
-     *
-     * @param position
-     * @param shapeArr the base
-     * @returns
-     * Imagine counting up in the base [2, 2]
-     * That would go: [0, 0], [1, 0], [0, 1], [1, 1] [x, y]
-     * Once the previous index hits the limit, the next count up and this index is back to 0
-     * so Pos -> index of [1, 0] is 1 (0 indexing)
-     *
-     * Invalid indexes like [0, 3] in base [2, 2] would be disallow but i didnt code this part in
-     */
-    static positionToIndex(position: ReadonlyArray<number>, shapeArr: ReadonlyArray<number>): number;
-    static isPositionOutOfBounds(position: ReadonlyArray<number>, shapeArr: ReadonlyArray<number>): boolean;
-    static isPartitioningManual(ps: partitionSetting): ps is partitionSetting.manual_mapping_no_ghost | partitionSetting.manual_mapping_with_ghost | partitionSetting.manual_mapping_with_ghost_spread;
-    static isPartitioningAuto(ps: partitionSetting): ps is partitionSetting.auto_mapping_types | partitionSetting.auto_mapping_subtypes | partitionSetting.auto_mapping_one_to_one | partitionSetting.auto_mapping_ygo;
-    static patchCardData(cData: cardData_unified, patchData: patchData): void;
-    static patchGeneric<T extends Object>(original: T, patch: Partial<T>, merge?: boolean): void;
-    static range(len: number, min?: number): number[];
-    static insertionSort<T extends any>(arr: T[], insertElement: T, comparator: ((a: T, b: T) => number)): void;
-    static getTypeSigature(val: any, simpleParse?: boolean): typeSignature;
-    static genericCurrier(f: any[], callback: (p: any[]) => any, res?: any[]): any;
-    static clone<T extends Object>(obj: T, recurDepth?: number): T;
-    static flat<T extends Exclude<any, Array<any> | any[]>>(nested: nestedTree<T> | T): T[];
-    static splitArrToShape<T>(arr: T[], shape: number[]): T[][];
-    static getRandomElement<T extends any[]>(arr: T): (T extends Array<infer R> ? R : never) | undefined;
-    static mergeGeneratorReturn<T>(gen1: recursiveGenerator<T[]>, gen2: recursiveGenerator<T[]>): Generator<any, T[], any>;
-    static addFinalToGenerator<T>(gen: recursiveGenerator<T[]>, f: (arr: T[]) => T[] | void): Generator<any, T[], any>;
-    static getRandomNumberArr(len: number): number[];
-    static isPositionable(o: any): o is Positionable;
-    static isPlayerSpecific(o: any): o is Player_specific;
-    /**
-     *
-     * @param arr1
-     * @param arr2
-     * Returns the intersection of the two array
-     */
-    static intersect<T extends safeSimpleTypes>(arr1: T[], arr2: T[]): T[];
-    static assert(a: any, b: any): void;
-    static assert(a: any, b: any, returns: true): boolean;
-    static assert(a: any, b: any, returns?: boolean): void;
-    static a_star<T_State>(startState: T_State, identity: (state: T_State) => number | string, evaluateState: (state: T_State, prev?: T_State) => number, //cheaper = better
-    evaluateTransition: (fromState: T_State, toState: T_State) => number, //cheaper = better
-    getNextStates: (current: T_State) => T_State[], stopCondition?: (state: T_State, f: number, g: number, totalPath: T_State[], depth: number) => boolean, maxDepth?: number): T_State[];
-}
-export declare class Heap<T> {
-    private data;
-    private comparator;
-    constructor(comparator: (a: T, b: T) => number, ...start: T[]);
-    push(item: T): void;
-    pop(): T | undefined;
-    top(): T | undefined;
-    get length(): number;
-    private bubbleUp;
-    private bubbleDown;
-}
-export default utils;