@overlayed/app 0.2.2 → 0.4.0

package/dist/siege.js

@@ -0,0 +1,326 @@
+import { type as a, scope as S } from "arktype";
+const p = "00000000-0000-0000-0000-000000000000", o = a(`string.uuid | '${p}'`), i = ["intro", "planning", "prep", "action", "results", "invalid"], l = a("===", ...i), m = [0, 1], r = a("===", ...m), s = ["attacker", "defender", "both", "invalid"], t = a("===", ...s), u = ["normal", "overhealed", "low_health", "downed", "dead", "respawning"], d = a("===", ...u), y = [
+  "bullet",
+  "melee",
+  "explosive",
+  "falling",
+  "regeneration",
+  "unknown",
+  "debris",
+  "projectile",
+  "downed",
+  "gas",
+  "thermal_explosion",
+  "melee_gadget",
+  "barbed_wire",
+  "electric",
+  "reinforcement",
+  "frag",
+  "paralyzed",
+  "emp",
+  "break",
+  "cleanup",
+  "interrogation",
+  "melee-finisher",
+  "toxic",
+  "toxic-explosion",
+  "pneumatic",
+  "body-contact",
+  "contact-explosion",
+  "flash",
+  "parasite-spike",
+  "laser",
+  "concussion",
+  "blowtorch",
+  "taser-shield",
+  "reverse-friendly-fire",
+  "self-destroyed",
+  "area-control",
+  "fire",
+  "breach-kick",
+  "break-wall",
+  "blade-mine",
+  "invalid"
+], c = a("===", ...y), g = ["unknown", "enemy", "friendly", "invalid"], b = a("===", ...g), x = a({
+  game: "string",
+  type: "string",
+  creation_time: "number"
+}), e = x.and({
+  game: "'siege'"
+}), k = e.and({
+  type: "'local_player'",
+  content: {
+    profile_id: o
+  }
+}), n = a({
+  id: "number",
+  value: "string"
+}), h = a({
+  kills: "number",
+  deaths: "number",
+  assists: "number",
+  plants: "number",
+  score: "number"
+}), E = a({
+  instigator_player_id: "number",
+  receiver_player_id: "number",
+  damage_amount: "number",
+  remaining_health: "number",
+  pre_damage_health: "number",
+  max_health: "number",
+  damage_type: c,
+  damage_team_type: b,
+  damage_item_id: "number | null",
+  damage_time: "number"
+}), f = a({
+  index: "number",
+  rounds_until_next_segment: "number",
+  segment_size: "number",
+  segment_index: "number",
+  team_0: {
+    role: t,
+    state: "number"
+  },
+  team_1: {
+    role: t,
+    state: "number"
+  }
+}), v = a({
+  id: "number",
+  name: n,
+  time_of_day: n
+}), w = a({
+  player_id: "number",
+  final_health: "number",
+  final_life_state: d,
+  operator_name: n.or(a.null)
+}), T = a({
+  round_data: f,
+  damage_events: E.array(),
+  players: w.array()
+}), A = e.and({
+  type: "'match_started'",
+  content: {
+    game_mode: "string",
+    game_type: n,
+    match_type: "string",
+    match_id: "string",
+    map: v,
+    is_round_based: "boolean",
+    current_round_index: "number",
+    rounds: f.array()
+  }
+}), M = e.and({
+  type: "'module_loaded'"
+}), P = e.and({
+  type: "'module_unloaded'"
+}), q = e.and({
+  type: "'started_queuing'",
+  content: {
+    game_mode: "string",
+    game_type: n,
+    match_type: "string"
+  }
+}), D = e.and({
+  type: "'stopped_queuing'"
+}), j = e.and({
+  type: "'unsupported_game_version'",
+  content: {
+    hash: "string | null",
+    version: "string | null"
+  }
+}), G = e.and({
+  type: "'match_ended'"
+}), I = e.and({
+  type: "'map_changed'",
+  content: {
+    map: v
+  }
+}), O = e.and({
+  type: "'operator_banned'",
+  content: {
+    index: "number",
+    team: r,
+    side: t,
+    operator_name: n.or("null")
+  }
+}), z = e.and({
+  type: "'round_ended'",
+  content: T
+}), L = e.and({
+  type: "'phase_changed'",
+  content: {
+    phase: l
+  }
+}), Y = e.and({
+  type: "'player_joined'",
+  content: {
+    player_id: "number",
+    profile_id: o,
+    is_bot: "boolean",
+    is_enemy: "boolean",
+    is_squad_member: "boolean",
+    is_local_player: "boolean",
+    username: "string",
+    side: t,
+    team: r,
+    is_privacy_username: "boolean",
+    has_avatar_hidden: "boolean",
+    has_commend_streak: "boolean",
+    ping_id: "number",
+    match_stats: h,
+    life_state: d,
+    ping: "number"
+  }
+}).pipe((_) => ({
+  ..._,
+  content: {
+    ..._.content,
+    starting_side: _.content.side
+  }
+})), B = e.and({
+  type: "'player_left'",
+  content: {
+    player_id: "number"
+  }
+}), F = e.and({
+  type: "'player_operator_changed'",
+  content: {
+    player_id: "number",
+    operator_name: n.or(a.null)
+  }
+}), H = e.and({
+  type: "'player_location_changed'",
+  content: {
+    player_id: "number",
+    location_name: "string"
+  }
+}), R = e.and({
+  type: "'player_side_changed'",
+  content: {
+    player_id: "number",
+    side: t
+  }
+}), $ = e.and({
+  type: "'player_stats_changed'",
+  content: {
+    player_id: "number",
+    match_stats: h
+  }
+}), C = e.and({
+  type: "'player_ping_updated'",
+  content: {
+    player_id: "number",
+    ping: "number"
+  }
+}), J = e.and({
+  type: "'defuser_planted'",
+  content: {
+    player_id: "number"
+  }
+}), K = e.and({
+  type: "'defuser_sabotaged'",
+  content: {
+    player_id: "number"
+  }
+}), N = e.and({
+  type: "'defuser_picked_up'",
+  content: {
+    player_id: "number",
+    initial: "boolean"
+  }
+}), Q = e.and({
+  type: "'defuser_dropped'",
+  content: {
+    player_id: "number"
+  }
+}), U = e.and({
+  type: "'player_life_state_changed'",
+  content: {
+    player_id: "number",
+    life_state: d
+  }
+}), V = e.and({
+  type: "'player_died'",
+  content: {
+    player_id: "number",
+    instigator_player_id: "number"
+  }
+}), W = e.and({
+  type: "'player_downed'",
+  content: {
+    player_id: "number",
+    instigator_player_id: "number"
+  }
+}), X = e.and({
+  type: "'player_ping_id_changed'",
+  content: {
+    player_id: "number",
+    ping_id: "number"
+  }
+}), Z = e.and({
+  type: "'player_team_changed'",
+  content: {
+    player_id: "number",
+    team: r
+  }
+}), ee = S({
+  "#event1": "module_loaded | module_unloaded | unsupported_game_version | local_player | started_queuing | stopped_queuing | match_started | match_ended | map_changed | operator_banned | round_ended | phase_changed | player_joined | player_left | player_operator_changed | player_location_changed | player_side_changed | player_stats_changed",
+  "#event2": "player_life_state_changed | player_died | player_downed | player_ping_id_changed | player_team_changed | defuser_planted | defuser_sabotaged | defuser_picked_up | defuser_dropped | player_ping_updated",
+  event: "event1 | event2",
+  module_loaded: M,
+  module_unloaded: P,
+  unsupported_game_version: j,
+  local_player: k,
+  started_queuing: q,
+  stopped_queuing: D,
+  match_started: A,
+  match_ended: G,
+  map_changed: I,
+  operator_banned: O,
+  round_ended: z,
+  phase_changed: L,
+  player_joined: Y,
+  player_left: B,
+  player_operator_changed: F,
+  player_location_changed: H,
+  player_side_changed: R,
+  player_stats_changed: $,
+  defuser_planted: J,
+  defuser_sabotaged: K,
+  defuser_picked_up: N,
+  defuser_dropped: Q,
+  player_ping_updated: C,
+  player_life_state_changed: U,
+  player_died: V,
+  player_downed: W,
+  player_ping_id_changed: X,
+  player_team_changed: Z
+}).export();
+function ae() {
+  return {
+    key: "siege",
+    events: ee
+  };
+}
+const te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BOT_ID: p,
+  DAMAGE_TEAM_TYPES: g,
+  DAMAGE_TYPES: y,
+  DamageTeamTypeSchema: b,
+  DamageTypeSchema: c,
+  GAME_MODE_PHASES: i,
+  GameModePhaseSchema: l,
+  PLAYER_LIFE_STATES: u,
+  PlayerLifeStateSchema: d,
+  ProfileId: o,
+  SIDES: s,
+  SideSchema: t,
+  TEAMS: m,
+  TeamSchema: r,
+  module: ae
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  te as Siege
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@overlayed/app",
   "author": "overlayed.gg",
   "homepage": "https://overlayed.gg",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Overlayed app",
   "license": "BSD-3-Clause",
   "repository": {
@@ -19,7 +19,13 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./siege": {
+      "types": "./dist/siege.d.ts",
+      "import": "./dist/siege.js",
+      "default": "./dist/siege.js"
     }
   },
   "files": [
@@ -38,23 +44,24 @@
   },
   "devDependencies": {
     "@ark/attest": "^0.45.0",
+    "@overlayed-gg/native-interface": "0.1.6",
+    "@overlayed-gg/render-interface": "0.1.6",
     "rollup-plugin-node-externals": "^8.0.0",
     "typescript": "^5.8.2",
     "vite": "^6.2.6",
     "vite-plugin-dts": "^4.5.3",
     "vite-plugin-static-copy": "^2.3.1",
     "vitest": "^3.0.9",
-    "@overlayed-gg/native-interface": "0.1.3",
-    "@overlayed-gg/render-interface": "0.1.4",
-    "@overlayed/api": "0.0.1",
-    "@overlayed/cortex-client": "0.0.1",
-    "@overlayed/events": "0.0.1",
-    "@overlayed/native-managers": "0.0.1",
-    "@overlayed/siege": "0.0.1",
-    "@overlayed/utils": "0.0.1"
+    "@overlayed/api": "0.0.2",
+    "@overlayed/cortex-client": "0.0.2",
+    "@overlayed/events": "0.0.2",
+    "@overlayed/native-managers": "0.0.2",
+    "@overlayed/siege": "0.0.2",
+    "@overlayed/utils": "0.0.2"
   },
   "dependencies": {
     "arktype": "^2.1.10",
+    "electron": "33.3.0",
     "jszip": "^3.10.1"
   },
   "engines": {

package/dist/config.d.ts

@@ -1,5 +0,0 @@
-export declare const config: {
-    env: string;
-    buildChannel: string;
-};
-//# sourceMappingURL=config.d.ts.map

package/dist/managers/errorManager.d.ts

@@ -1,34 +0,0 @@
-import { EventEmitterManager } from './manager';
-export interface ErrorEvent {
-    message: string;
-    code: ErrorEventCode;
-    data?: Record<string, any>;
-    timestamp: number;
-}
-export interface WarningEvent {
-    message: string;
-    code: WarningEventCode;
-    data?: Record<string, any>;
-    timestamp: number;
-}
-export type ErrorEventCode = "ELEVATION_MISMATCH";
-export type WarningEventCode = "";
-export interface ErrorManagerEvents {
-    error: ErrorEvent;
-    warning: WarningEvent;
-}
-declare class ErrorManager extends EventEmitterManager<ErrorManagerEvents> {
-    constructor();
-    error(message: string, code: ErrorEventCode, data?: Record<string, any>): void;
-    warn(message: string, code: WarningEventCode, data?: Record<string, any>): void;
-}
-export declare const errorManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: ErrorManager | undefined;
-    getInstance(): ErrorManager;
-    clearInstance(): void;
-} & typeof ErrorManager, "new">;
-export {};
-//# sourceMappingURL=errorManager.d.ts.map

package/dist/managers/gameBuildManager.d.ts

@@ -1,18 +0,0 @@
-import { Manager } from './manager';
-declare class GameBuildManager extends Manager {
-    private readonly boundOnGameLaunch;
-    constructor();
-    init(): void;
-    destroy(): void;
-    private onGameLaunch;
-}
-export declare const gameBuildManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: GameBuildManager | undefined;
-    getInstance(): GameBuildManager;
-    clearInstance(): void;
-} & typeof GameBuildManager, "new">;
-export {};
-//# sourceMappingURL=gameBuildManager.d.ts.map

package/dist/managers/gameLaunchManager.d.ts

@@ -1,36 +0,0 @@
-import { EventEmitterManager } from './manager';
-import { RavenGame } from '@overlayed/api';
-import { Process } from '@overlayed-gg/native-interface';
-export type GameLaunchManagerEvents = {
-    gameLaunch: {
-        ravenGame: RavenGame;
-        process: Process;
-    };
-    gameClose: {
-        ravenGame: RavenGame;
-        process: Process;
-    };
-};
-declare class GameLaunchManager extends EventEmitterManager<GameLaunchManagerEvents> {
-    private readonly RENDER_INTERFACE_PATH;
-    private readonly boundOnProcessCreate;
-    private readonly boundOnProcessDestroy;
-    constructor();
-    init(): void;
-    destroy(): void;
-    private onProcessCreate;
-    private copyDll;
-    private getDllFiles;
-    private onProcessDestroy;
-    private getRavenGame;
-}
-export declare const gameLaunchManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: GameLaunchManager | undefined;
-    getInstance(): GameLaunchManager;
-    clearInstance(): void;
-} & typeof GameLaunchManager, "new">;
-export {};
-//# sourceMappingURL=gameLaunchManager.d.ts.map

package/dist/managers/keybindManager.d.ts

@@ -1,38 +0,0 @@
-import { OverlayedAppKeybindsConfig } from '../types';
-import { EventEmitterManager } from './manager';
-export type KeybindManagerEvents = {
-    keybindPressed: [keys: string];
-};
-export type KeybindPressedCallback = () => string | void;
-export type KeybindDownCallback = () => string | void;
-export type KeybindUpCallback = () => void;
-export type KeybindCallbacks = {
-    toggle?: KeybindPressedCallback;
-    down?: KeybindDownCallback;
-    up?: KeybindUpCallback;
-};
-export declare class KeybindManager extends EventEmitterManager<KeybindManagerEvents> {
-    private preferencesKeybindToCallbacks;
-    private pressedKeys;
-    private activeKeybinds;
-    private triggeredToggleKeybinds;
-    isRecording: boolean;
-    private readonly boundHandleKeyboardFocus;
-    private readonly boundHandleKeyDown;
-    private readonly boundHandleKeyUp;
-    private keybidnsFile;
-    constructor(config: OverlayedAppKeybindsConfig<string>);
-    init(): void;
-    onHotkeyToggled(preferencesHotkeyKey: string, callback: KeybindPressedCallback): Promise<void>;
-    onHotkeyDown(preferencesHotkeyKey: string, callback: KeybindDownCallback): Promise<void>;
-    onHotkeyUp(preferencesHotkeyKey: string, callback: KeybindUpCallback): Promise<void>;
-    destroy(): void;
-    private handleKeyDown;
-    private handleKeyboardFocus;
-    private handleKeyUp;
-    private checkHotkeyUps;
-    private checkKeybindings;
-    private triggerHotkey;
-    private getHotkeyToString;
-}
-//# sourceMappingURL=keybindManager.d.ts.map

package/dist/managers/manager.d.ts

@@ -1,18 +0,0 @@
-import { CustomLoggerScope, EventEmitter } from '@overlayed/utils';
-/** This should be kept in sync with EventEmitterManager */
-export declare class Manager {
-    protected logger: CustomLoggerScope;
-    initialized: boolean;
-    constructor(name: string);
-    init(): void;
-    destroy(): void;
-}
-/** This should be kept in sync with Manager */
-export declare class EventEmitterManager<T extends Record<string, any>> extends EventEmitter<T> {
-    protected logger: CustomLoggerScope;
-    initialized: boolean;
-    constructor(name: string);
-    init(): void;
-    destroy(): void;
-}
-//# sourceMappingURL=manager.d.ts.map

package/dist/managers/nativeModuleManager.d.ts

@@ -1,31 +0,0 @@
-import { EventEmitterManager } from './manager';
-export type NativeDllManagerEvents = {
-    dllUpdated: {
-        identifier: string;
-        version: string;
-    };
-};
-declare class NativeDllManager extends EventEmitterManager<NativeDllManagerEvents> {
-    private readonly UPDATE_CHECK_INTERVAL_MS;
-    private targetDir;
-    private updateInterval?;
-    constructor();
-    initWithDlls(dlls_to_inject: string[]): Promise<void>;
-    destroy(): void;
-    getCurrentVersion(identifier: string): Promise<string | null>;
-    getTargetPath(identifier: string): string;
-    getTargetVersionPath(identifier: string, version: string): string;
-    private checkForUpdates;
-    private downloadAndExtractDll;
-    private cleanupOldVersions;
-}
-export declare const nativeModuleManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: NativeDllManager | undefined;
-    getInstance(): NativeDllManager;
-    clearInstance(): void;
-} & typeof NativeDllManager, "new">;
-export {};
-//# sourceMappingURL=nativeModuleManager.d.ts.map

package/dist/managers/processManager.d.ts

@@ -1,34 +0,0 @@
-import { EventEmitterManager } from './manager';
-import { Process } from '@overlayed-gg/native-interface';
-export type ProcessManagerEvents = {
-    create: {
-        process: Process;
-    };
-    destroy: {
-        process: Process;
-    };
-};
-declare class ProcessManager extends EventEmitterManager<ProcessManagerEvents> {
-    private readonly _processMonitor;
-    private readonly _processes;
-    private readonly boundOnRavenManagerExecutablesUpdated;
-    constructor();
-    get hasAnyActiveProcesses(): boolean;
-    get activeProcesses(): Process[];
-    init(): void;
-    destroy(): void;
-    isProcessRunning(name: string): boolean;
-    private onRavenManagerExecutablesUpdated;
-    private addProcess;
-    private deleteProcess;
-}
-export declare const processManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: ProcessManager | undefined;
-    getInstance(): ProcessManager;
-    clearInstance(): void;
-} & typeof ProcessManager, "new">;
-export {};
-//# sourceMappingURL=processManager.d.ts.map

package/dist/managers/ravenManager.d.ts

@@ -1,35 +0,0 @@
-import { EventEmitterManager } from './manager';
-import { RavenGame } from '@overlayed/api';
-export type RavenManagerEvents = {
-    executablesUpdated: {
-        executables: string[];
-        map: RavenManager["_executableToGameMap"];
-    };
-};
-declare class RavenManager extends EventEmitterManager<RavenManagerEvents> {
-    private readonly REFETCH_INTERVAL;
-    private readonly FAILED_REFETCH_INTERVAL;
-    private _ravenConfig;
-    private _executableToGameMap;
-    private _executablesArray;
-    private _refetchIntervalHandler;
-    private _failedRefetchTimeoutHandler;
-    constructor();
-    init(): void;
-    getExecutableData(executable: string): RavenGame | null;
-    get executables(): string[];
-    get executablesMap(): Map<string, RavenGame>;
-    destroy(): void;
-    private fetchRavenConfig;
-    private resetState;
-}
-export declare const ravenManager: Omit<{
-    new (...args: any[]): {
-        [x: string]: any;
-    };
-    _instance?: RavenManager | undefined;
-    getInstance(): RavenManager;
-    clearInstance(): void;
-} & typeof RavenManager, "new">;
-export {};
-//# sourceMappingURL=ravenManager.d.ts.map

package/dist/overlayed.d.ts

@@ -1,4 +0,0 @@
-import { GameModule } from '@overlayed/events';
-import { OverlayedData, OverlayedApp } from './types';
-export declare function overlayed<TModule extends GameModule, TShortcut extends string>(data: OverlayedData<TModule, TShortcut>): OverlayedApp<TModule, TShortcut>;
-//# sourceMappingURL=overlayed.d.ts.map