index.d.ts

declare module "alt-server" {
  export interface Player {
    store: ReturnType<
      typeof import("../../src/shared/store/player.store").usePlayerStore
    >;
  }
}

server.ts

this.store.$subscribe(
  (mutation, state) => {
    if (!mutation.events) {
      this.emitRaw(Events.Client.SET_STATE, toRaw(state));
      return;
    }
    const events = Array.isArray(mutation.events)
      ? mutation.events
      : [mutation.events];

    for (const event of events) {
      const path = findPath(toRaw(state), event.target)?.join(".");

      const { type, target, key, newValue } = event;

      let payload;
      switch (type) {
        case "add":
          payload = { type, path, target: toRaw(target) };
          break;
        case "set":
          payload = { type, path, key, newValue: toRaw(newValue) };
          break;
        case "delete":
          payload = { type, path, key };
          break;
        case "clear":
          payload = { type, path };
          break;
      }
      if (payload) {
        this.emitRaw(Events.Client.UPDATE_STATE, payload);
      }
    }
  },
  { immediate: true, flush: "sync" }
);

update-store-state.ts

import { get, set } from "lodash-es";
import { Store } from "pinia";

export function updateStoreState<S extends Store>(
  store: S,
  event: { type: string; target: any; key: string; newValue: any; path: string }
) {
  const { type, target, key, newValue, path } = event;

  switch (type) {
    case "add":
      if (path) {
        set(store.$state, path, target);
      }
      break;
    case "set":
      set(store.$state, `${path ? path + "." : ""}${key}`, newValue);
      break;
    case "delete":
      if (path) {
        delete get(store.$state, path)[key];
      } else {
        delete (store.$state as any)[key];
      }
      break;
    case "clear":
      if (path) {
        get(store.$state, path)?.clear();
      }
      break;
  }
}