@voltro/plugin-social 0.0.0-stage → 0.88.0

package/dist/testing.js

@@ -0,0 +1,85 @@
+import { socialError as e } from "./errors.js";
+import { SocialBlockPort as t } from "./port.js";
+import { distinctRecentPeers as n, mutualMatchSuggestions as r, recipientRequestPolicy as i, resolveSocialOptions as a } from "./strategies.js";
+import { Effect as o, Layer as s, Result as c } from "effect";
+// src/testing.ts
+var l = (t = {}) => ({
+	isBlocked: () => o.fail(e("unavailable")),
+	blockPairs: () => o.fail(e("unavailable")),
+	canMessage: () => o.fail(e("unavailable")),
+	canInvite: () => o.fail(e("unavailable")),
+	recordRecent: () => o.fail(e("unavailable")),
+	...t
+}), u = (e = {}) => s.sync(t, () => l(e)), d = u(), f = {
+	kind: "port",
+	tag: t,
+	fakeLayer: d,
+	probe: {
+		run: () => o.scoped(t.pipe(o.flatMap((e) => e.isBlocked({
+			type: "user",
+			id: "one",
+			tenantId: "tenant"
+		}, "two")), o.result, o.map((e) => c.isFailure(e) ? e.failure.code : e.success), o.provide(d))),
+		expected: "unavailable"
+	}
+}, p = {
+	ownerId: "one",
+	requestsFrom: "nobody",
+	showOnline: !1,
+	showActivity: !1,
+	allowPartyInvites: "friends",
+	metadata: {}
+}, m = [{
+	subjectId: "one",
+	mutualFriends: 2,
+	recentMatches: 0
+}, {
+	subjectId: "two",
+	mutualFriends: 1,
+	recentMatches: 1
+}], h = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => o.sync(() => r(m, 1).map((e) => e.subjectId)),
+		expected: ["two"]
+	},
+	overrideProbe: {
+		run: () => o.sync(() => a({ strategies: { suggestions: (e, t) => [...e].sort((e, t) => t.mutualFriends - e.mutualFriends).slice(0, t) } }).strategies.suggestions(m, 1).map((e) => e.subjectId)),
+		expected: ["one"]
+	}
+}, g = {
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => o.sync(() => i({
+			settings: p,
+			mutualFriends: 0
+		})),
+		expected: !1
+	},
+	overrideProbe: {
+		run: () => o.sync(() => a({ strategies: { requestPolicy: () => !0 } }).strategies.requestPolicy({
+			settings: p,
+			mutualFriends: 0
+		})),
+		expected: !0
+	}
+}, _ = {
+	ownerId: "one",
+	otherId: "two",
+	context: "match",
+	at: 1
+}, v = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => o.sync(() => n(_)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => o.sync(() => a({ strategies: { recentPolicy: () => !1 } }).strategies.recentPolicy(_)),
+		expected: !1
+	}
+};
+export { u as fakeSocialBlockLayer, l as fakeSocialBlockService, d as socialBlockFakeLayer, f as socialBlockPortFixture, v as socialRecentPolicyFixture, g as socialRequestPolicyFixture, h as socialSuggestionsFixture };

package/dist/web.d.ts

@@ -0,0 +1,162 @@
+import { ReactNode } from 'react';
+import { SubscriptionState } from '@voltro/client';
+
+/** Parent owns request state across closing/reopening. The component never replays an uncertain mutation. */
+export declare const AddFriendDialog: ({ open, onOpenChange, query, onQueryChange, found, scopeKey, pending, error, labels, onFind, onRequest }: {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    readonly query: string;
+    readonly onQueryChange: (query: string) => void;
+    readonly found: FoundFriend | null | undefined;
+    readonly scopeKey: string;
+    readonly pending?: boolean;
+    readonly error?: unknown;
+    readonly labels?: AddFriendLabels;
+    readonly onFind: (query: string) => void;
+    readonly onRequest: (subjectId: string) => void;
+}) => ReactNode;
+
+export declare interface AddFriendLabels {
+    readonly title: string;
+    readonly description: string;
+    readonly name: string;
+    readonly find: string;
+    readonly request: string;
+    readonly close: string;
+    readonly notFound: string;
+    readonly failed: string;
+}
+
+export declare const addFriendLabels: Readonly<Record<'en' | 'de', AddFriendLabels>>;
+
+export declare interface FoundFriend extends Pick<FriendView, 'subjectId' | 'displayName' | 'tag'> {
+    readonly query: string;
+    readonly scopeKey: string;
+}
+
+export declare interface FriendActions {
+    readonly onInvite?: (subjectId: string) => void;
+    readonly onMessage?: (subjectId: string) => void;
+    readonly onProfile?: (subjectId: string) => void;
+}
+
+/** Names/status must be server projections supplied by Players/Presence, never client-written roster metadata. */
+export declare const FriendRow: ({ friend, labels, pending, onInvite, onMessage, onProfile }: {
+    readonly friend: FriendView;
+    readonly labels?: FriendsLabels;
+    readonly pending?: boolean;
+} & FriendActions) => ReactNode;
+
+export declare interface FriendsLabels {
+    readonly title: string;
+    readonly empty: string;
+    readonly loading: string;
+    readonly error: string;
+    readonly online: string;
+    readonly offline: string;
+    readonly unknown: string;
+    readonly invite: string;
+    readonly message: string;
+    readonly profile: string;
+}
+
+export declare const friendsLabels: Readonly<Record<'en' | 'de', FriendsLabels>>;
+
+export declare const FriendsPanel: ({ friends, loading, error, pending, labels, ...actions }: FriendsPanelProps) => ReactNode;
+
+export declare interface FriendsPanelProps extends FriendActions {
+    readonly friends: ReadonlyArray<FriendView>;
+    readonly loading?: boolean;
+    readonly error?: unknown;
+    readonly pending?: boolean;
+    readonly labels?: FriendsLabels;
+}
+
+export declare interface FriendView {
+    readonly subjectId: string;
+    readonly displayName: string;
+    readonly tag: string;
+    readonly online: boolean | null;
+    readonly activity: string | null;
+}
+
+export declare const useBlockList: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly fromId: string;
+    readonly toId: string;
+    readonly kind: "request" | "friend" | "block" | "favorite";
+    readonly createdAt: number;
+    readonly respondedAt: number | null;
+    readonly note: string | null;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useFavoriteFriends: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly fromId: string;
+    readonly toId: string;
+    readonly kind: "request" | "friend" | "block" | "favorite";
+    readonly createdAt: number;
+    readonly respondedAt: number | null;
+    readonly note: string | null;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useFriendRequests: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly fromId: string;
+    readonly toId: string;
+    readonly kind: "request" | "friend" | "block" | "favorite";
+    readonly createdAt: number;
+    readonly respondedAt: number | null;
+    readonly note: string | null;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useFriends: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly fromId: string;
+    readonly toId: string;
+    readonly kind: "request" | "friend" | "block" | "favorite";
+    readonly createdAt: number;
+    readonly respondedAt: number | null;
+    readonly note: string | null;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useRecentPlayers: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly otherId: string;
+    readonly context: string;
+    readonly at: number;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useSocialSettings: (apiName?: string) => SubscriptionState<{
+    readonly ownerId: string;
+    readonly requestsFrom: "anyone" | "friends-of-friends" | "nobody";
+    readonly showOnline: boolean;
+    readonly showActivity: boolean;
+    readonly allowPartyInvites: "anyone" | "friends";
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}>;
+
+export declare const useSocialSuggestions: (apiName?: string) => SubscriptionState<readonly {
+    readonly subjectId: string;
+    readonly mutualFriends: number;
+    readonly recentMatches: number;
+}[]>;
+
+export { }

package/dist/web.js

@@ -0,0 +1,7 @@
+import { BASE_NAME as e } from "./rpc.js";
+import { AddFriendDialog as t, FriendRow as n, FriendsPanel as r, addFriendLabels as i, friendsLabels as a } from "./components.js";
+import { pluginTag as o } from "@voltro/protocol";
+import { useSubscription as s } from "@voltro/client";
+// src/web.ts
+var c = (t = "app") => s(t, o(e, "friends"), {}), l = (t = "app") => s(t, o(e, "favorites"), {}), u = (t = "app") => s(t, o(e, "requests"), {}), d = (t = "app") => s(t, o(e, "blocked"), {}), f = (t = "app") => s(t, o(e, "recent"), {}), p = (t = "app") => s(t, o(e, "suggestions"), {}), m = (t = "app") => s(t, o(e, "settings"), {});
+export { t as AddFriendDialog, n as FriendRow, r as FriendsPanel, i as addFriendLabels, a as friendsLabels, d as useBlockList, l as useFavoriteFriends, u as useFriendRequests, c as useFriends, f as useRecentPlayers, m as useSocialSettings, p as useSocialSuggestions };

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@voltro/plugin-social",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.88.0",
+  "description": "SQL-owned social graph with symmetric block admission and configurable policies",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
+    "./port": {
+      "types": "./dist/port.d.ts",
+      "import": "./dist/port.js",
+      "default": "./dist/port.js"
+    },
+    "./strategies": {
+      "types": "./dist/strategies.d.ts",
+      "import": "./dist/strategies.js",
+      "default": "./dist/strategies.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js",
+      "default": "./dist/web.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "import": "./dist/events.js",
+      "default": "./dist/events.js"
+    },
+    "./events/server": {
+      "types": "./dist/eventProducer.d.ts",
+      "import": "./dist/eventProducer.js",
+      "default": "./dist/eventProducer.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/protocol": "0.88.0",
+    "@voltro/database": "0.88.0",
+    "@voltro/client": "0.88.0",
+    "@voltro/runtime": "0.88.0",
+    "@voltro/plugin-ratelimit": "0.88.0",
+    "@voltro/kv": "0.88.0",
+    "@voltro/ui-shadcn": "0.88.0",
+    "@voltro/plugin-licensing": "0.88.0"
+  },
+  "peerDependencies": {
+    "effect": "4.1.0",
+    "react": "^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}