overlay-toolkit 0.9.0

package/README.md

@@ -0,0 +1,4 @@
+# Overlay Toolkit Library
+
+An API wrapper for [OverlayToolkit](https://github.com/Lotlab/ffxiv-overlay-toolkit), which is function collection extend ffxiv overlay plugin.
+

package/dist/ffxiv.d.ts

@@ -0,0 +1,654 @@
+export interface LogLineEntry {
+    /**
+     * Line type of log line, in human friendly string
+     */
+    readonly type: string;
+    /**
+     * Line type of log line, in decimal
+     */
+    readonly typeCode: number;
+    /**
+     * Time of log line, in TZ (ISO 8601) format
+     */
+    readonly time: string;
+}
+export declare class LogLineBase implements LogLineEntry {
+    type: string;
+    typeCode: number;
+    time: string;
+    constructor(type: string, log: string[]);
+    get timeDate(): Date;
+}
+/**
+ * Game log line, DO NOT WRITE TRIGGER AGAINST THIS
+ */
+export declare class GameLogLine extends LogLineBase {
+    code: string;
+    name: string;
+    line: string;
+    constructor(log: string[]);
+}
+/**
+ * This message is sent when first logging in and whenever the zone is changed.
+ */
+export declare class ChangeZone extends LogLineBase {
+    /**
+     * Zone ID of the zone, in decimal
+     */
+    zoneID: number;
+    /**
+     * Zone name of the zone, in human friendly string
+     */
+    zoneName: string;
+    constructor(log: string[]);
+}
+/**
+ * This message is sent when the primary player changes.
+ */
+export declare class ChangePrimaryPlayer extends LogLineBase {
+    /**
+     * Character ID of the character, in decimal
+     */
+    charID: number;
+    /**
+     * Character name of the character, in human friendly string
+     */
+    charName: string;
+    constructor(log: string[]);
+    get charIDHex(): string;
+}
+/**
+ * This message is sent when a new object is added to the scene or becomes close enough to the player that they can view its actions.
+ */
+export declare class AddCombatant extends LogLineBase {
+    /**
+     * ID of the combatant, in decimal
+     */
+    id: number;
+    /**
+     * Name of the combatant, in human friendly string
+     */
+    name: string;
+    job: number;
+    level: number;
+    ownerID: number;
+    worldID: number;
+    worldName: string;
+    npcNameID: number;
+    npcBaseID: number;
+    currentHP: number;
+    hp: number;
+    currentMP: number;
+    mp: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+/**
+ * This message is sent when an object is removed from the scene, either because the player has moved too far away from it, it has died, or the player has changed zones.
+ */
+export declare class RemoveCombatant extends LogLineBase {
+    /**
+     * ID of the combatant, in decimal
+     */
+    id: number;
+    name: string;
+    job: number;
+    level: number;
+    ownerID: number;
+    world: string;
+    npcNameID: number;
+    npcBaseID: number;
+    currentHP: number;
+    hp: number;
+    currentMP: number;
+    mp: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+/**
+ * This line represents the players currently in the party, and is sent whenever the party makeup changes.
+ *
+ * This data is not necessarily sorted in the same order as the in-game party UI.
+ */
+export declare class PartyList extends LogLineBase {
+    /**
+     * IDs of the players in the party, in decimal
+     */
+    party: number[];
+    constructor(log: string[]);
+}
+/**
+ * This message is sent whenever your player's stats change and upon entering a new zone/instance.
+ *
+ * This is only emitted for the local player. It is not possible to automatically pull other players' stats.
+ */
+export declare class PlayerStats extends LogLineBase {
+    job: number;
+    strength: number;
+    dexterity: number;
+    vitality: number;
+    intelligence: number;
+    mind: number;
+    piety: number;
+    attackPower: number;
+    directHit: number;
+    criticalHit: number;
+    attakcMagicPotency: number;
+    healingMagicPotency: number;
+    determination: number;
+    skillSpeed: number;
+    spellSpeed: number;
+    tenacity: number;
+    localContentID: number;
+    constructor(log: string[]);
+}
+/**
+ * For abilities with cast bars, this is the log line that specifies that a player or a monster has started casting an ability.
+ * This precedes a NetworkAbility, NetworkAOEAbility, or NetworkCancelAbility where it uses the ability or is interrupted.
+ */
+export declare class NetowrkStartsCasting extends LogLineBase {
+    sourceID: number;
+    sourceName: string;
+    id: number;
+    ability: string;
+    targetID: number;
+    targetName: string;
+    castTime: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+export interface ActionEffect {
+    flags: number;
+    damage: string;
+}
+/**
+ * This is an ability that ends up hitting a single target (possibly the caster's self). The reason this is worded as "ends up hitting" is that some AOE abilities may only hit a single target, in which case they still result in this type
+ */
+export declare class NetworkAbility extends LogLineBase {
+    sourceID: number;
+    sourceName: string;
+    id: number;
+    ability: string;
+    targetID: number;
+    targetName: string;
+    effects: ActionEffect[];
+    targetCurrentHP: number;
+    targetMaxHP: number;
+    targetCurrentMP: number;
+    targetMaxMP: number;
+    targetX: number;
+    targetY: number;
+    targetZ: number;
+    targetHeading: number;
+    currentHP: number;
+    maxHP: number;
+    currentMP: number;
+    maxMP: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    sequence: number;
+    targetIndex: number;
+    targetCount: number;
+    ownerID: number;
+    ownerName: string;
+    effectDisplayType: number;
+    actionID: number;
+    actionAnimationID: number;
+    animationLockTime: number;
+    rotationHex: number;
+    constructor(log: string[]);
+}
+/**
+ * For abilities with cast bars, this is the log line that specifies that the cast was cancelled either due to movement or an interrupt and it won't go off.
+ */
+export declare class NetworkCancelAbility extends LogLineBase {
+    sourceID: number;
+    source: string;
+    id: number;
+    name: string;
+    reason: string;
+    constructor(log: string[]);
+}
+/**
+ * HoT (heal over time) and DoT (damage over time) amounts. For most DoTs and HoTs, this line conveys an aggregated tick for every DoT/HoT source on that target from all sources.
+ */
+export declare class NetworkDoT extends LogLineBase {
+    id: number;
+    name: string;
+    which: string;
+    effectID: number;
+    damage: number;
+    currentHP: number;
+    maxHP: number;
+    currentMP: number;
+    maxMP: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    sourceID: number;
+    sourceName: string;
+    damageType: number;
+    sourceCurrentHP: number;
+    sourceMaxHP: number;
+    sourceCurrentMP: number;
+    sourceMaxMP: number;
+    sourceX: number;
+    sourceY: number;
+    sourceZ: number;
+    sourceHeading: number;
+    constructor(log: string[]);
+}
+/**
+ * This message corresponds to an actor being defeated and killed. This usually comes along with a game log message such as You defeat the worm's heart.
+ */
+export declare class NetworkDeath extends LogLineBase {
+    targetID: number;
+    targetName: string;
+    sourceID: number;
+    sourceName: string;
+    constructor(log: string[]);
+}
+/**
+ * This message is the "gains effect" message for players and mobs gaining effects whether they are good or bad.
+ */
+export declare class NetworkBuff extends LogLineBase {
+    effectID: number;
+    effectName: string;
+    duration: number;
+    sourceID: number;
+    sourceName: string;
+    targetID: number;
+    targetName: string;
+    count: number;
+    targetMaxHP: number;
+    sourceMaxHP: number;
+    constructor(log: string[]);
+}
+export declare class NetworkTargetIcon extends LogLineBase {
+    targetID: number;
+    targetName: string;
+    id: number;
+    data0: number;
+    constructor(log: string[]);
+}
+/**
+ * This message indicates a floor waymarker was added or deleted.
+ */
+export declare class NetworkRaidMarker extends LogLineBase {
+    operation: string;
+    waymark: number;
+    id: number;
+    name: string;
+    x: number;
+    y: number;
+    z: number;
+    constructor(log: string[]);
+}
+/**
+ * This message indicates a target marker placed above or removed from a combatant's head by a player.
+ */
+export declare class NetworkTargetMarker extends LogLineBase {
+    operation: string;
+    waymark: number;
+    id: number;
+    name: string;
+    targetID: number;
+    targetName: string;
+    constructor(log: string[]);
+}
+/**
+ * This is the paired "end" message to the NetworkBuff "begin" message. This message corresponds to the loss of effects (either positive or negative).
+ */
+export declare class NetworkBuffRemove extends LogLineBase {
+    effectID: number;
+    effectName: string;
+    sourceID: number;
+    sourceName: string;
+    targetID: number;
+    targetName: string;
+    count: number;
+    constructor(log: string[]);
+}
+/**
+ * Info about the current player's job gauge.
+ */
+export declare class NetworkGauge extends LogLineBase {
+    id: number;
+    /**
+     * The data of the gauge, in a Uint8Array.
+     *
+     * First byte is always the job.
+     */
+    data: Uint8Array;
+    constructor(log: string[]);
+}
+/**
+ * To control aspects of the user interface, the game sends packets called Actor Controls.
+ * These are broken into 3 types: ActorControl, ActorControlSelf, and ActorControlTarget.
+ * If ActorControl is global, then ActorControlSelf / ActorControlTarget affects individual actor(s).
+ */
+export declare class NetworkActorControl extends LogLineBase {
+    instance: number;
+    command: number;
+    data: number[];
+    constructor(log: string[]);
+}
+/**
+ * This log message toggles whether the nameplate for a particular entity is visible or not. This can help you know when a mob is targetable, for example.
+ */
+export declare class NetworkNameToggle extends LogLineBase {
+    id: number;
+    name: string;
+    targetID: number;
+    targetName: string;
+    /**
+     * 1 = show, 0 = hide
+     */
+    toggle: boolean;
+    constructor(log: string[]);
+}
+/**
+ * This log line is for tethers between enemies or enemies and players. This does not appear to be used for player to player skill tethers like dragonsight or cover. (It can be used for enemy-inflicted player to player tethers such as burning chains in Shinryu N/EX.)
+ */
+export declare class NetworkTether extends LogLineBase {
+    sourceID: number;
+    sourceName: string;
+    targetID: number;
+    targetName: string;
+    id: number;
+    constructor(log: string[]);
+}
+/**
+ * This log line is recorded every server tick where limit break energy is generated while in combat in a light or full party.
+ */
+export declare class LimitBreak extends LogLineBase {
+    /**
+     * The limit break value, in decimal. Maximum value is 10000 * bars
+     */
+    value: number;
+    bars: number;
+    constructor(log: string[]);
+}
+export declare class NetworkActionSync extends LogLineBase {
+    id: number;
+    name: string;
+    sequenceID: number;
+    currentHP: number;
+    maxHP: number;
+    currentMP: number;
+    maxMP: number;
+    currentShield: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+export declare class NetworkStatusEffects extends LogLineBase {
+    targetID: number;
+    targetName: string;
+    jobLevelData: number;
+    currentHP: number;
+    maxHP: number;
+    currentMP: number;
+    maxMP: number;
+    currentShield: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    data: number[];
+    constructor(log: string[]);
+}
+/**
+ * This line represents passive HP/MP regen ticks. It conveys the new values for HP/MP. Like Line 37 and Line 38, the HP value is an update, rather than a value in memory.
+ */
+export declare class NetworkUpdateHP extends LogLineBase {
+    id: number;
+    name: string;
+    currentHP: number;
+    maxHP: number;
+    currentMP: number;
+    maxMP: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+/**
+ * This line is sent when the map changes. It will be sent when changing zones, but is also sent when changing subzones where the map changes (e.g. crossing a zone line while in a dungeon).
+ */
+export declare class MapLog extends LogLineBase {
+    id: number;
+    regionName: string;
+    placeName: string;
+    placeNameSub: string;
+    constructor(log: string[]);
+}
+/**
+ * This log line is sent when there are system log messages.
+ */
+export declare class SystemLogMessage extends LogLineBase {
+    instance: number;
+    id: number;
+    params: number[];
+    constructor(log: string[]);
+}
+export declare class StatusList3 extends LogLineBase {
+    id: number;
+    name: string;
+    statusList: number[];
+    constructor(log: string[]);
+}
+export declare class Debug extends LogLineBase {
+    message: string;
+    constructor(log: string[]);
+}
+export declare class PacketDump extends LogLineBase {
+    len: number;
+    src: number;
+    dst: number;
+    packetType: number;
+    data?: Uint8Array;
+    constructor(log: string[]);
+}
+export declare class Version extends LogLineBase {
+    message: string;
+    constructor(log: string[]);
+}
+export declare class Error extends LogLineBase {
+    message: string;
+    constructor(log: string[]);
+}
+/**
+ * This line is emitted into logs when any custom logs are registered with OverlayPlugin.
+ * This is so that it is obvious which log lines and versions to expect for a given log file.
+ */
+export declare class LineRegistration extends LogLineBase {
+    id: number;
+    source: string;
+    name: string;
+    version: string;
+    constructor(log: string[]);
+}
+/**
+ * This message is sent to cause a specific visual effect to render in the game client during instanced content.
+ * MapEffect lines are not tied to any particular actor or action but may provide visual-based information about how an upcoming mechanic will resolve.
+ */
+export declare class MapEffect extends LogLineBase {
+    instance: number;
+    flags: number;
+    location: number;
+    data0: number;
+    data1: number;
+    constructor(log: string[]);
+}
+export declare class FateDirector extends LogLineBase {
+    category: string;
+    unknown: number;
+    id: number;
+    progress: number;
+    constructor(log: string[]);
+}
+export declare class CEDirector extends LogLineBase {
+    popTime: number;
+    timeRemaining: number;
+    unknown: number;
+    ceKey: number;
+    numPlayers: number;
+    status: number;
+    unknown2: number;
+    progress: number;
+    constructor(log: string[]);
+}
+/**
+ * This log line tracks in combat state. inGameCombat is whether FFXIV itself considers you in combat. inACTCombat is whether ACT considers you in combat, which may include other people around you and not yourself and also takes your ACT encounter settings into consideration.
+ */
+export declare class InCombat extends LogLineBase {
+    inACTCombat: boolean;
+    inGameCombat: boolean;
+    isACTChanged: boolean;
+    isGameChanged: boolean;
+    constructor(log: string[]);
+}
+export declare class CombatantMemory extends LogLineBase {
+    change: string;
+    id: number;
+    data: Map<string, string>;
+    constructor(log: string[]);
+}
+export declare class RSVData extends LogLineBase {
+    locale: string;
+    unknown: number;
+    key: string;
+    value: string;
+    constructor(log: string[]);
+}
+export declare class StartsUsingExtra extends LogLineBase {
+    sourceID: number;
+    id: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    constructor(log: string[]);
+}
+/**
+ * This line contains extra data for Ability/NetworkAOEAbility network data.
+ */
+export declare class AbilityExtra extends LogLineBase {
+    sourceID: number;
+    id: number;
+    globalEffectCounter: number;
+    dataFlag: number;
+    x: number;
+    y: number;
+    z: number;
+    heading: number;
+    animationTargetId: number;
+    constructor(log: string[]);
+}
+export declare class ContentFinderSettings extends LogLineBase {
+    zoneID: number;
+    zoneName: string;
+    inContentFinderContent: boolean;
+    unrestrictedParty: boolean;
+    minimalItemLevel: boolean;
+    silenceEcho: boolean;
+    explorerMode: boolean;
+    levelSync: boolean;
+    constructor(log: string[]);
+}
+export declare class NpcYell extends LogLineBase {
+    npcId: number;
+    npcNameId: number;
+    npcYellId: number;
+    constructor(log: string[]);
+}
+export declare class BattleTalk2 extends LogLineBase {
+    npcId: number;
+    instance: number;
+    npcNameId: number;
+    instanceContentTextId: number;
+    displayMs: number;
+    constructor(log: string[]);
+}
+export declare class Countdown extends LogLineBase {
+    id: number;
+    worldID: number;
+    countdownTime: number;
+    result: number;
+    name: string;
+    constructor(log: string[]);
+}
+export declare class CountdownCancel extends LogLineBase {
+    id: number;
+    worldID: number;
+    name: string;
+    constructor(log: string[]);
+}
+export declare class ActorMove extends LogLineBase {
+    id: number;
+    heading: number;
+    unk1: number;
+    unk2: number;
+    x: number;
+    y: number;
+    z: number;
+    constructor(log: string[]);
+}
+export declare class ActorSetPos extends LogLineBase {
+    id: number;
+    heading: number;
+    unk1: number;
+    unk2: number;
+    x: number;
+    y: number;
+    z: number;
+    constructor(log: string[]);
+}
+export declare class SpawnNpcExtra extends LogLineBase {
+    id: number;
+    parentID: number;
+    tetherID: number;
+    animationState: number;
+    constructor(log: string[]);
+}
+export declare class ActorControlExtra extends LogLineBase {
+    id: number;
+    category: number;
+    param1: number;
+    param2: number;
+    param3: number;
+    param4: number;
+    constructor(log: string[]);
+}
+export declare class ActorControlSelfExtra extends LogLineBase {
+    id: number;
+    category: number;
+    param1: number;
+    param2: number;
+    param3: number;
+    param4: number;
+    param5: number;
+    param6: number;
+    constructor(log: string[]);
+}
+export declare class UnknownLogLine extends LogLineBase {
+    rawLines: string[];
+    constructor(log: string[]);
+}
+export declare function ParseLogLine(log: string[]): LogLineEntry;

package/dist/hid.d.ts

@@ -0,0 +1,46 @@
+export interface OverlayHID extends EventTarget {
+    onconnect: ((this: this, ev: OverlayHIDConnectionEvent) => any) | null;
+    ondisconnect: ((this: this, ev: OverlayHIDConnectionEvent) => any) | null;
+    getDevices(): Promise<OverlayHIDDevice[]>;
+    requestDevice(options?: HIDDeviceRequestOptions): Promise<OverlayHIDDevice[]>;
+    addEventListener(type: "connect" | "disconnect", listener: (this: this, ev: OverlayHIDConnectionEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: "connect" | "disconnect", callback: (this: this, ev: OverlayHIDConnectionEvent) => any, useCapture?: boolean): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+export declare function NewHID(): OverlayHID;
+interface HIDDeviceInfo {
+    readonly vendorId: number;
+    readonly productId: number;
+    readonly productName: string;
+    readonly collections: HIDCollectionInfo[];
+}
+export interface OverlayHIDDevice extends HIDDeviceInfo, EventTarget {
+    oninputreport: ((this: OverlayHIDDevice, ev: OverlayHIDInputReportEvent) => any) | null;
+    opened: boolean;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    forget(): Promise<void>;
+    sendReport(reportId: number, data: BufferSource): Promise<void>;
+    sendFeatureReport(reportId: number, data: BufferSource): Promise<void>;
+    receiveFeatureReport(reportId: number): Promise<DataView>;
+    addEventListener(type: "inputreport", listener: (this: OverlayHIDDevice, ev: OverlayHIDInputReportEvent) => any): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: "inputreport", callback: (this: OverlayHIDDevice, ev: OverlayHIDInputReportEvent) => any): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}
+export interface OverlayHIDConnectionEvent extends Event {
+    readonly device: OverlayHIDDevice;
+}
+export interface OverlayHIDInputEvent extends Event {
+    readonly device: OverlayHIDDevice;
+    readonly reportId: number;
+    readonly data: DataView;
+}
+declare class OverlayHIDInputReportEvent extends Event implements OverlayHIDInputEvent {
+    readonly device: OverlayHIDDevice;
+    readonly reportId: number;
+    readonly data: DataView;
+    constructor(type: string, device: OverlayHIDDevice, reportId: number, data: DataView);
+}
+export {};

package/dist/hid.helper.d.ts

@@ -0,0 +1,9 @@
+export type TypedEventTarget<EventMap extends object> = {
+    new (): IntermediateEventTarget<EventMap>;
+};
+export interface IntermediateEventTarget<EventMap> extends EventTarget {
+    addEventListener<K extends keyof EventMap>(type: K, callback: (event: EventMap[K] extends Event ? EventMap[K] : never) => EventMap[K] extends Event ? void : never, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof EventMap>(type: K, callback: (event: EventMap[K] extends Event ? EventMap[K] : never) => EventMap[K] extends Event ? void : never, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+}