@overlayed/app 0.13.1 → 0.14.0

package/dist/index.d.ts

@@ -1,12 +1,10 @@
+import * as arktype0 from "arktype";
+import { Module, Type } from "arktype";
+import EventEmitter$1 from "events";
 import * as electron0 from "electron";
 import { BrowserWindow } from "electron";
-import { EventCallback, EventType, GameModule, GameModuleEventInfer } from "@overlayed/events";
-import * as arktype_internal_attributes_ts0 from "arktype/internal/attributes.ts";
 import * as arktype_internal_methods_object_ts0 from "arktype/internal/methods/object.ts";
-import { CustomLoggerScope, ErrorManagerEvents } from "@overlayed/utils-node";
-import { GameModel, setUpdaterTokenResolver } from "@overlayed/api";
 import { Process } from "@overlayed-gg/native-interface";
-import { MaybePromise } from "@overlayed/utils";
 import {
 	AccessLevel,
 	KeyboardKeyEvent,
@@ -20,8 +18,196 @@ import {
 	VirtualKey,
 	WindowEvent,
 } from "@overlayed-gg/render-interface";
-import { RenderInterfaceName } from "@overlayed/native-managers";
 
+//#region ../utils/dist/index.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+type Result<T, E = string> = [T, undefined] | [undefined, E];
+//#endregion
+//#region src/utilities.d.ts
+
+//#endregion
+//#region src/brand.d.ts
+/**
+ * A `Brand` is a type that takes at minimum two type parameters. Given a base
+ * type `Base` and some unique and arbitrary branding type `Branding`, it
+ * produces a type based on but distinct from `Base`. The resulting branded
+ * type is not directly assignable from the base type, and not mutually
+ * assignable with another branded type derived from the same base type.
+ *
+ * Take care that the branding type is unique. Two branded types that share the
+ * same base type and branding type are considered the same type! There are two
+ * ways to avoid this.
+ *
+ * The first way is to supply a third type parameter, `ReservedName`, with a
+ * string literal type that is not `__type__`, which is the default.
+ *
+ * The second way is to define a branded type in terms of its surrounding
+ * interface, thereby forming a recursive type. This is possible because there
+ * are no constraints on what the branding type must be. It does not have to
+ * be a string literal type, even though it often is.
+ *
+ * @example
+ * ```
+ * type Path = Brand<string, 'path'>;
+ * type UserId = Brand<number, 'user'>;
+ * type DifferentUserId = Brand<number, 'user', '__kind__'>;
+ * interface Post { id: Brand<number, Post> }
+ * ```
+ */
+type Brand<Base, Branding, ReservedName extends string = "__type__"> = Base & { [K in ReservedName]: Branding } & {
+	__witness__: Base;
+};
+/**
+ * An `AnyBrand` is a branded type based on any base type branded with any
+ * branding type. By itself it is not useful, but it can act as type constraint
+ * when manipulating branded types in general.
+ */
+//#endregion
+//#region ../utils-node/dist/index.d.ts
+//#endregion
+//#region src/asSingleton.d.ts
+type Singleton<T extends new (...args: any[]) => any> = T & {
+	getInstance: () => InstanceType<T>;
+	clearInstance: () => void;
+};
+//#endregion
+//#region src/logger.d.ts
+interface LoggerScope {
+	scope: (name: string) => LoggerScope;
+	error: (...args: unknown[]) => void;
+	warn: (...args: unknown[]) => void;
+	info: (...args: unknown[]) => void;
+	log: (...args: unknown[]) => void;
+}
+declare class LoggerClass {
+	private fileLogger;
+	private path;
+	private appId;
+	private messageQueue;
+	fileName: string;
+	constructor(fileName: string);
+	init(appId: string): void;
+	scope(name: string): LoggerScope;
+	error(...args: unknown[]): void;
+	warn(...args: unknown[]): void;
+	info(...args: unknown[]): void;
+	debug(...args: unknown[]): void;
+	log(...args: unknown[]): void;
+	private handle;
+}
+declare const Logger: Singleton<typeof LoggerClass>;
+type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>;
+//#endregion
+//#region src/consts.d.ts
+
+//#endregion
+//#region src/errorManager.d.ts
+type ErrorManagerEvent = {
+	code: string;
+	message: string;
+	data: Record<string, any>;
+	timestamp: number;
+};
+interface FatalElevationMismatch extends ErrorManagerEvent {
+	code: "ELEVATION_MISMATCH";
+	data: {
+		appElevated: boolean;
+		gameElevated: boolean;
+	};
+}
+interface ErrorPipeServerError extends ErrorManagerEvent {
+	code: "PIPE_SERVER_ERROR";
+	data: {
+		error: unknown;
+	};
+}
+interface ErrorInvalidConfigFile extends ErrorManagerEvent {
+	code: "INVALID_CONFIG_FILE";
+	data: {
+		issues: string[];
+		filePath: string;
+		data: unknown;
+	};
+}
+interface WarningInvalidEvent extends ErrorManagerEvent {
+	code: "INVALID_EVENT";
+	data: {
+		summary: string;
+	};
+}
+type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile;
+type WarningEvents = WarningInvalidEvent;
+type FatalEvents = FatalElevationMismatch;
+type ErrorManagerEvents = {
+	fatal: FatalEvents;
+	error: ErrorEvents;
+	warning: WarningEvents;
+};
+interface OverlayedConfig {
+	/**
+	 * Your Overlayed application ID.
+	 */
+	applicationId: string;
+	/**
+	 * The bundle config for your electron app.
+	 */
+	app: BundleAppConfig;
+	/**
+	 * The optional bundle config for your site.
+	 */
+	site?: BundleSiteConfig;
+}
+interface BundleConfigBase {
+	/**
+	 * String or array of string [glob](https://www.npmjs.com/package/glob) patterns to bundle.
+	 *
+	 * `package.json` is always included.
+	 */
+	include: MaybeArray<string>;
+	/**
+	 * String or array of string [glob](https://www.npmjs.com/package/glob) patterns to exclude from the bundle.
+	 *
+	 * `/installer` is always excluded.
+	 */
+	exclude?: string | string[];
+}
+interface BundleAppConfig extends BundleConfigBase {}
+interface BundleSiteConfig extends BundleConfigBase {}
+declare function defineConfig(config: OverlayedConfig): OverlayedConfig;
+//#endregion
+//#region ../events/dist/index.d.ts
+//#endregion
+//#region src/utils.d.ts
+declare const BaseEvent: Type<{
+	game: string;
+	type: string;
+	creation_time: number;
+}>;
+type BaseEvent = typeof BaseEvent.infer;
+//#endregion
+//#region src/types.d.ts
+type EventType<TEvent extends BaseEvent> = TEvent["type"];
+type GameModuleEvent<TEvents extends Record<string, BaseEvent>> = TEvents & {
+	event: BaseEvent;
+};
+type GameModuleEventInfer<TModule extends GameModule> = TModule["events"]["event"]["infer"];
+interface GameModule<
+	TEvents extends Record<string, BaseEvent> = Record<string, BaseEvent>,
+	TKey extends string = string,
+> {
+	key: TKey;
+	events: Module<GameModuleEvent<TEvents>>;
+}
+type EventCallback<TEvent extends BaseEvent, TEventType extends EventType<TEvent>> = (
+	event: Extract<
+		TEvent,
+		{
+			type: TEventType;
+		}
+	>,
+) => void;
+//#endregion
 //#region src/managers/manager.d.ts
 /** This should be kept in sync with EventEmitterManager */
 declare class Manager {
@@ -46,13 +232,27 @@ declare const KeybindSchema: arktype_internal_methods_object_ts0.ObjectType<
 	{
 		[x: string]: {
 			keys: string[];
-			mode: (In: "toggle" | "hold") => arktype_internal_attributes_ts0.Out<"toggle" | "hold">;
+			mode: (In: "toggle" | "hold") => arktype0.Out<"toggle" | "hold">;
 		};
 	},
 	{}
 >;
 type KeybindSchemaEntry = (typeof KeybindSchema.infer)[string];
 //#endregion
+//#region ../api/dist/index.d.ts
+//#endregion
+//#region src/endpoints/raven/games.d.ts
+interface GameModel {
+	name: string;
+	identifier: Brand<string, GameModel>;
+	modules: string[];
+	executables: string[];
+}
+//#endregion
+//#region src/instances.d.ts
+declare function setUpdaterTokenResolver(newTokenResolver: () => string | undefined): void;
+//#endregion
+//#endregion
 //#region src/managers/gameLaunchManager.d.ts
 type GameLaunchManagerEvents = {
 	gameCloseInternal: (args: { ravenGame: GameModel; process: Process }) => MaybePromise<void>;
@@ -77,6 +277,10 @@ interface OverridesManagerScope {
 	setKeyInputBlock: (key: number, block: boolean) => void;
 }
 //#endregion
+//#region ../native-managers/dist/index.d.ts
+//#region src/renderInterfaceManager.d.ts
+type RenderInterfaceName = "OGG_SIEGE";
+//#endregion
 //#region src/managers/overridesManager.d.ts
 declare class OverridesManager extends Manager {
 	private renderInterface;
@@ -282,7 +486,7 @@ interface OverlayedAppInputModule {
 	scope: (scopeName: string) => ReturnType<OverridesManager["scope"]>;
 	raw: OverlayedAppInputModuleRaw;
 }
-interface CortexEvents extends Record<string, unknown> {}
+interface CortexEvents {}
 interface OverlayedAppCortexModule {
 	track: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
 }
@@ -440,17 +644,21 @@ declare function setFetchLatestTokenCallback(newFetchLatestToken: () => Promise<
 export {
 	type AccessLevel,
 	ActiveGameInfo,
+	type BundleAppConfig,
+	type BundleSiteConfig,
 	type GameLaunchManagerEvents,
 	type KeybindSchemaEntry as KeybindConfig,
 	type KeyboardKeyEvent,
 	type MouseButtonEvent,
 	type OverlayedApp,
+	type OverlayedConfig,
 	OverridesManagerScope,
 	type RenderInterface,
 	type RenderWindow,
 	type RenderWindowConstructorOptions,
 	type VirtualKey,
 	type WindowEvent,
+	defineConfig,
 	overlayed,
 	setFetchLatestTokenCallback,
 	setUpdaterTokenResolver,