@warpfx/server 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @warp/server — Typed SDK for Warp server-side module development.
+ *
+ * Provides type-safe access to the Warp core API. Under the hood,
+ * all calls go through FiveM's resource exports to the 'warp' resource.
+ *
+ * Usage:
+ *   import { onReady, provide, use, getEvents } from '@warp/server';
+ *
+ *   onReady(() => {
+ *     const events = getEvents();
+ *     events.on('player:spawned', (data) => { ... });
+ *     provide('economy', new EconomyService());
+ *   });
+ */
+/** Player lifecycle event data. */
+interface PlayerEventContext {
+    /** FiveM server-side player ID. */
+    source: number;
+    /** Citizen ID (license identifier). */
+    citizenId: string;
+    /** Display name. */
+    name: string;
+}
+/** Player data row from the database cache. */
+interface PlayerRow {
+    citizenId: string;
+    name: string;
+    online: boolean;
+    lastSeen: bigint;
+}
+/** Typed event bus for server-side and network communication. */
+interface ServerEventBus<TMap extends Record<string, any> = Record<string, any>> {
+    /** Subscribe to a local event. Returns an unsubscribe function. */
+    on<K extends string & keyof TMap>(event: K, handler: (data: TMap[K]) => void): () => void;
+    /** Unsubscribe from a local event. */
+    off<K extends string & keyof TMap>(event: K, handler: (data: TMap[K]) => void): void;
+    /** Emit a local event to all subscribers. */
+    emit<K extends string & keyof TMap>(event: K, data: TMap[K]): void;
+    /** Send an event to a specific client. */
+    emitClient<K extends string & keyof TMap>(event: K, target: number, data: TMap[K]): void;
+    /** Broadcast an event to all connected clients. */
+    emitAllClients<K extends string & keyof TMap>(event: K, data: TMap[K]): void;
+    /** Listen for events from clients. Returns an unsubscribe function. */
+    onClient<K extends string & keyof TMap>(event: K, handler: (source: number, data: TMap[K]) => void): () => void;
+    /** Unsubscribe from a client event. */
+    offClient<K extends string & keyof TMap>(event: K, handler: (source: number, data: TMap[K]) => void): void;
+}
+/** ECS-inspired entity component store. */
+interface EntityStore {
+    /** Attach a component to an entity. */
+    attach<T>(entityId: string, component: string, data: T): void;
+    /** Get a component from an entity. Returns undefined if not found. */
+    get<T>(entityId: string, component: string): T | undefined;
+    /** Remove a component from an entity. */
+    detach(entityId: string, component: string): boolean;
+    /** Remove all components for an entity. */
+    removeEntity(entityId: string): void;
+    /** Check if an entity has a specific component. */
+    has(entityId: string, component: string): boolean;
+    /** Iterate all entities that have a specific component. */
+    query<T>(component: string): IterableIterator<[string, T]>;
+}
+/**
+ * Register a callback to run when Warp is fully booted.
+ * If Warp is already ready, the callback fires immediately.
+ * All other SDK functions should be called inside this callback.
+ */
+declare function onReady(cb: () => void): void;
+/** Check if Warp has finished booting. */
+declare function isReady(): boolean;
+/** Register a service that other modules can resolve via use(). */
+declare function provide<T>(token: string, service: T): void;
+/** Resolve a service registered by another module. */
+declare function use<T = unknown>(token: string): T;
+/** Get the shared event bus instance. */
+declare function getEvents<TMap extends Record<string, any> = Record<string, any>>(): ServerEventBus<TMap>;
+/** Get the shared entity component store. */
+declare function getEntities(): EntityStore;
+/** Find a player by citizenId from the database cache. */
+declare function getPlayer(citizenId: string): PlayerRow | null;
+/** Get all cached players. */
+declare function getPlayers(): PlayerRow[];
+/** Register a callback for when a player connects (database confirmed). */
+declare function onPlayerConnect(cb: (player: PlayerEventContext) => void): void;
+/** Register a callback for when a player disconnects. */
+declare function onPlayerDisconnect(cb: (player: PlayerEventContext) => void): void;
+/**
+ * Get the database bridge for direct table and reducer access.
+ * Advanced — most modules should use the event bus and DI instead.
+ */
+declare function getBridge(): any;
+/** Subscribe to database tables. Call inside onReady(). */
+declare function subscribe(queries: string[]): Promise<void>;
+
+export { type EntityStore, type PlayerEventContext, type PlayerRow, type ServerEventBus, getBridge, getEntities, getEvents, getPlayer, getPlayers, isReady, onPlayerConnect, onPlayerDisconnect, onReady, provide, subscribe, use };

package/dist/index.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getBridge: () => getBridge,
+  getEntities: () => getEntities,
+  getEvents: () => getEvents,
+  getPlayer: () => getPlayer,
+  getPlayers: () => getPlayers,
+  isReady: () => isReady,
+  onPlayerConnect: () => onPlayerConnect,
+  onPlayerDisconnect: () => onPlayerDisconnect,
+  onReady: () => onReady,
+  provide: () => provide,
+  subscribe: () => subscribe,
+  use: () => use
+});
+module.exports = __toCommonJS(index_exports);
+function warp() {
+  return globalThis.exports["warp"];
+}
+function onReady(cb) {
+  warp().onReady(cb);
+}
+function isReady() {
+  return warp().isReady();
+}
+function provide(token, service) {
+  warp().provide(token, service);
+}
+function use(token) {
+  return warp().use(token);
+}
+function getEvents() {
+  return warp().getEvents();
+}
+function getEntities() {
+  return warp().getEntities();
+}
+function getPlayer(citizenId) {
+  return warp().getPlayer(citizenId);
+}
+function getPlayers() {
+  return warp().getPlayers();
+}
+function onPlayerConnect(cb) {
+  warp().onPlayerConnect(cb);
+}
+function onPlayerDisconnect(cb) {
+  warp().onPlayerDisconnect(cb);
+}
+function getBridge() {
+  return warp().getBridge();
+}
+function subscribe(queries) {
+  return warp().subscribe(queries);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBridge,
+  getEntities,
+  getEvents,
+  getPlayer,
+  getPlayers,
+  isReady,
+  onPlayerConnect,
+  onPlayerDisconnect,
+  onReady,
+  provide,
+  subscribe,
+  use
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@warpfx/server",
+  "version": "0.1.0",
+  "description": "Warp Framework SDK for server-side FiveM module development",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1camou/warp.git",
+    "directory": "packages/server"
+  },
+  "keywords": ["fivem", "warp", "server", "framework"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts --out-dir dist --target node22"
+  }
+}