warscript 0.0.1-dev.404878c

package/time/year.d.ts

@@ -0,0 +1,117 @@
+/** @noSelfInFile */
+import { BinaryReader } from "../binaryreader";
+import { BinaryWriter } from "../binarywriter";
+/**
+ * A year in the ISO-8601 calendar system, such as {@code 2007}.
+ * <p>
+ * {@code Year} is an immutable date-time object that represents a year.
+ * Any field that can be derived from a year can be obtained.
+ * <p>
+ * <b>Note that years in the ISO chronology only align with years in the
+ * Gregorian-Julian system for modern years. Parts of Russia did not switch to the
+ * modern Gregorian/ISO rules until 1920.
+ * As such, historical years must be treated with caution.</b>
+ * <p>
+ * This class does not store or represent a month, day, time or time-zone.
+ * For example, the value "2007" can be stored in a {@code Year}.
+ * <p>
+ * Years represented by this class follow the ISO-8601 standard and use
+ * the proleptic numbering system. Year 1 is preceded by year 0, then by year -1.
+ * <p>
+ * The ISO-8601 calendar system is the modern civil calendar system used today
+ * in most of the world. It is equivalent to the proleptic Gregorian calendar
+ * system, in which today's rules for leap years are applied for all time.
+ * For most applications written today, the ISO-8601 rules are entirely suitable.
+ * However, any application that makes use of historical dates, and requires them
+ * to be accurate will find the ISO-8601 approach unsuitable.
+ */
+export declare class Year {
+    readonly value: number;
+    /**
+     * The minimum supported year, '-999,999,999'.
+     */
+    static readonly MIN_VALUE = -999999999;
+    /**
+     * The maximum supported year, '+999,999,999'.
+     */
+    static readonly MAX_VALUE = 999999999;
+    private constructor();
+    /**
+     * Obtains the current year from the system clock in the default time-zone.
+     * <p>
+     * This will query the {@link os#date() system clock} in the default
+     * time-zone to obtain the current year.
+     *
+     * @return the current year using the system clock and default time-zone
+     */
+    static now(): Year;
+    /**
+     * Obtains an instance of {@code Year}.
+     * <p>
+     * This method accepts a year value from the proleptic ISO calendar system.
+     * <p>
+     * The year 2AD/CE is represented by 2.<br>
+     * The year 1AD/CE is represented by 1.<br>
+     * The year 1BC/BCE is represented by 0.<br>
+     * The year 2BC/BCE is represented by -1.<br>
+     *
+     * @param isoYear  the ISO proleptic year to represent, from {@code MIN_VALUE} to {@code MAX_VALUE}
+     * @return the year
+     */
+    static of(isoYear: number): Year;
+    static deserialize(reader: BinaryReader): Year;
+    serialize(writer: BinaryWriter): void;
+    /**
+     * Checks if the year is a leap year, according to the ISO proleptic
+     * calendar system rules.
+     * <p>
+     * This method applies the current rules for leap years across the whole time-line.
+     * In general, a year is a leap year if it is divisible by four without
+     * remainder. However, years divisible by 100, are not leap years, with
+     * the exception of years divisible by 400 which are.
+     * <p>
+     * For example, 1904 is a leap year it is divisible by 4.
+     * 1900 was not a leap year as it is divisible by 100, however 2000 was a
+     * leap year as it is divisible by 400.
+     * <p>
+     * The calculation is proleptic - applying the same rules into the far future and far past.
+     * This is historically inaccurate, but is correct for the ISO-8601 standard.
+     *
+     * @param year  the year to check
+     * @return true if the year is leap, false otherwise
+     */
+    static isLeap(year: number): boolean;
+    /**
+     * Checks if the year is a leap year, according to the ISO proleptic
+     * calendar system rules.
+     * <p>
+     * This method applies the current rules for leap years across the whole time-line.
+     * In general, a year is a leap year if it is divisible by four without
+     * remainder. However, years divisible by 100, are not leap years, with
+     * the exception of years divisible by 400 which are.
+     * <p>
+     * For example, 1904 is a leap year it is divisible by 4.
+     * 1900 was not a leap year as it is divisible by 100, however 2000 was a
+     * leap year as it is divisible by 400.
+     * <p>
+     * The calculation is proleptic - applying the same rules into the far future and far past.
+     * This is historically inaccurate, but is correct for the ISO-8601 standard.
+     *
+     * @return true if the year is leap, false otherwise
+     */
+    get isLeap(): boolean;
+    /**
+     * Gets the length of this year in days.
+     *
+     * @return the length of this year in days, 365 or 366
+     */
+    get length(): number;
+    /**
+     * Outputs this year as a {@code string}.
+     *
+     * @return a string representation of this year
+     */
+    toString(): string;
+    private __lt;
+    private __le;
+}

package/time/year.lua

@@ -0,0 +1,81 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local date = os.date
+local cache = setmetatable({}, {__mode = "v"})
+--- A year in the ISO-8601 calendar system, such as {@code 2007}.
+-- <p>
+-- {@code Year} is an immutable date-time object that represents a year.
+-- Any field that can be derived from a year can be obtained.
+-- <p>
+-- <b>Note that years in the ISO chronology only align with years in the
+-- Gregorian-Julian system for modern years. Parts of Russia did not switch to the
+-- modern Gregorian/ISO rules until 1920.
+-- As such, historical years must be treated with caution.</b>
+-- <p>
+-- This class does not store or represent a month, day, time or time-zone.
+-- For example, the value "2007" can be stored in a {@code Year}.
+-- <p>
+-- Years represented by this class follow the ISO-8601 standard and use
+-- the proleptic numbering system. Year 1 is preceded by year 0, then by year -1.
+-- <p>
+-- The ISO-8601 calendar system is the modern civil calendar system used today
+-- in most of the world. It is equivalent to the proleptic Gregorian calendar
+-- system, in which today's rules for leap years are applied for all time.
+-- For most applications written today, the ISO-8601 rules are entirely suitable.
+-- However, any application that makes use of historical dates, and requires them
+-- to be accurate will find the ISO-8601 approach unsuitable.
+____exports.Year = __TS__Class()
+local Year = ____exports.Year
+Year.name = "Year"
+function Year.prototype.____constructor(self, value)
+    self.value = value
+    assert(math.type(value) == "integer" and value >= ____exports.Year.MIN_VALUE and value <= ____exports.Year.MAX_VALUE)
+    cache[value] = self
+end
+function Year.now(self)
+    local value = date("*t").year
+    return cache[value] or __TS__New(____exports.Year, value)
+end
+function Year.of(self, isoYear)
+    return cache[isoYear] or __TS__New(____exports.Year, isoYear)
+end
+function Year.deserialize(self, reader)
+    return ____exports.Year:of(reader:readInt32())
+end
+function Year.prototype.serialize(self, writer)
+    writer:writeInt32(self.value)
+end
+function Year.isLeap(self, year)
+    return year & 3 == 0 and (year % 100 ~= 0 or year % 400 == 0)
+end
+function Year.prototype.__tostring(self)
+    return tostring(self.value)
+end
+function Year.prototype.__lt(self, other)
+    return self.value < other.value
+end
+function Year.prototype.__le(self, other)
+    return self.value <= other.value
+end
+Year.MIN_VALUE = -999999999
+Year.MAX_VALUE = 999999999
+__TS__SetDescriptor(
+    Year.prototype,
+    "isLeap",
+    {get = function(self)
+        return ____exports.Year:isLeap(self.value)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Year.prototype,
+    "length",
+    {get = function(self)
+        return self.isLeap and 366 or 365
+    end},
+    true
+)
+return ____exports

package/types.d.ts

@@ -0,0 +1,13 @@
+import "./decl/index"
+
+declare global {
+    type KeysOfType<T, U> = {
+        [P in keyof T]: T[P] extends U ? P : never
+    }[keyof T]
+
+    type NonConstructorKeys<T> = {
+        [P in keyof T]: T[P] extends new () => any ? never : P
+    }[keyof T]
+
+    type OmitConstructor<T> = Pick<T, NonConstructorKeys<T>>
+}

package/util/objectPool.d.ts

@@ -0,0 +1,6 @@
+/** @noSelfInFile */
+export declare class ObjectPool<T> {
+    readonly get: (this: void) => T;
+    readonly release: (this: void, object: T) => void;
+    constructor(create: () => T, cleanUp?: (object: T) => void);
+}

package/util/objectPool.lua

@@ -0,0 +1,28 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local function noOp()
+end
+____exports.ObjectPool = __TS__Class()
+local ObjectPool = ____exports.ObjectPool
+ObjectPool.name = "ObjectPool"
+function ObjectPool.prototype.____constructor(self, create, cleanUp)
+    if cleanUp == nil then
+        cleanUp = noOp
+    end
+    local pool = {}
+    local n = 1
+    self.get = function()
+        if n > 1 then
+            n = n - 1
+            return pool[n]
+        end
+        return create()
+    end
+    self.release = function(object)
+        cleanUp(object)
+        pool[n] = object
+        n = n + 1
+    end
+end
+return ____exports

package/util/stream.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+export interface Stream<T> {
+    toArray(): T[];
+    toSet(): Set<T>;
+    groupingBy<R>(f: (this: void, value: T) => R): Map<R, T[]>;
+    joining(sep: string): string;
+    forEach(f: (this: void, value: T) => any): void;
+    count(): number;
+    findFirst(): T | null;
+    reduce<U>(identity: U, accumulator: (this: void, acc: U, value: T) => U): U;
+    peek(f: (this: void, value: T) => any): Stream<T>;
+    map<S>(f: (this: void, value: T) => S): Stream<S>;
+    flatMap<S>(f: (value: T) => Stream<S>): Stream<S>;
+}
+export declare namespace Stream {
+    function of<T>(array: T[]): Stream<T>;
+    function ofReversed<T>(array: T[]): Stream<T>;
+    function ofNullable<T>(element: T | null | undefined): Stream<T>;
+    function range(startInclusive: number, endExclusive: number, step?: number): Stream<number>;
+    function rangeClosed(startInclusive: number, endInclusive: number, step?: number): Stream<number>;
+}
+export interface EntryStream<K, V> extends Stream<[K, V]> {
+    invert(): EntryStream<V, K>;
+    toMap(): Map<K, V>;
+}
+export declare namespace EntryStream {
+    function of<K, V>(map: Map<K, V> | LuaTable<K & {}, V>): EntryStream<K, V>;
+}