insite-users-client 1.0.27 → 2.0.0

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "insite-users-client",
-  "version": "1.0.27",
+  "version": "2.0.0",
   "description": "inSite users client side",
   "type": "module",
-  "main": "./lib/index.js",
-  "module": "./lib/index.js",
-  "packageManager": "bun@1.1.9",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "packageManager": "bun@1.1.26",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "bun .conveyer.js",
+    "postbuild": "tsc -p ."
   },
   "repository": {
     "type": "git",
@@ -21,9 +23,13 @@
   "author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
   "license": "MIT",
   "dependencies": {
-    "insite-subscriptions-client": "^1"
+    "@nesvet/n": "^1.1.7",
+    "insite-common": "^2",
+    "insite-subscriptions-client": "^2"
   },
   "devDependencies": {
-    "@nesvet/eslint-config": "^1"
+    "@nesvet/conveyer": "^2.2.4",
+    "@nesvet/eslint-config": "^2.0.25",
+    "typescript": "^5.5.4"
   }
 }

package/src/UsersSubscriptionGroup.ts

@@ -0,0 +1,75 @@
+import {
+	SubscriptionGroup,
+	type SubscriptionGroupOptions,
+	type SubscriptionMapWithSubscription,
+	type SubscriptionObjectWithSubscription
+} from "insite-subscriptions-client";
+import { handleExtendedOrgs, handleOrgs, handleOrgsBeforeSubscribe } from "./orgs";
+import { handleRoles } from "./roles";
+import { handleUser } from "./user";
+import { handleExtendedUsers, handleUsers } from "./users";
+
+
+const basisDefinitions = [
+	[ "orgs", "map", handleOrgs, handleOrgsBeforeSubscribe ],
+	[ "users", "map", handleUsers ],
+	[ "user", [ true ], handleUser ]
+];
+
+const extendedDefinitions = [
+	[ "roles", "map", handleRoles ],
+	[ "extendedUsers", "map", "users.extended", handleExtendedUsers, true ],
+	[ "extendedOrgs", "map", "orgs.extended", handleExtendedOrgs, true ]
+];
+
+export class UsersSubscriptionGroup extends SubscriptionGroup<typeof basisDefinitions | typeof extendedDefinitions> {
+	constructor(options: SubscriptionGroupOptions) {
+		super(basisDefinitions, options);
+		
+	}
+	
+	isExtended: boolean | null = false;
+	
+	extend() {
+		
+		if (this.isExtended === false) {
+			this.isExtended = null;
+			
+			return this.attach(extendedDefinitions).then(() => {
+				
+				this.isExtended = true;
+				
+			});
+		}
+		
+		return null;
+	}
+	
+	unextend() {
+		
+		if (this.isExtended) {
+			this.isExtended = false;
+			
+			this.detach([ "roles", "extendedUsers", "extendedOrgs" ]);
+		}
+		
+	}
+	
+	
+	static handleValues({
+		orgs,
+		users,
+		user
+	}: {
+		orgs: SubscriptionMapWithSubscription;
+		users: SubscriptionMapWithSubscription;
+		user: SubscriptionObjectWithSubscription;
+	}, options: SubscriptionGroupOptions) {
+		return new SubscriptionGroup([
+			[ "orgs", orgs, handleOrgs, handleOrgsBeforeSubscribe ],
+			[ "users", users, handleUsers ],
+			[ "user", user, handleUser ]
+		], options);
+	}
+	
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export type { NullOrg, Org, OrgExtended, Orgs, OrgsExtended } from "./orgs";
+export type { Role, Roles } from "./roles";
+export type { CurrentUser } from "./user";
+export type { User, UserExtended, Users, UsersExtended } from "./users";
+export * from "./UsersSubscriptionGroup";

package/src/orgs.ts

@@ -0,0 +1,110 @@
+import { getAll } from "@nesvet/n";
+import type { SubscriptionMapUpdated, SubscriptionMapWithSubscription } from "insite-subscriptions-client";
+import type { User } from "./users";
+import type { UsersSubscriptionGroup } from "./UsersSubscriptionGroup";
+
+
+export type Org = {
+	_id: string;
+	title: string;
+	isOrg: true;
+	users: { sorted: User[] } & Set<User>;
+};
+
+export type NullOrg = { _id: null } & Omit<Org, "_id">;
+
+type OrgExtension = {
+	_id: string;
+	owners: string[];
+	slaveOrgs: string[];
+	note: string;
+};
+
+export type OrgExtended = {
+	owners?: (OrgExtended | User)[];
+	slaveOrgs?: OrgExtended[];
+	note?: string;
+	_l?: number;
+} & Org;
+
+type OrgsExtra = {
+	null: NullOrg;
+};
+
+export type Orgs = OrgsExtra & SubscriptionMapWithSubscription<Org>;
+
+export type OrgsExtended = {
+	sortedHierarchically?: OrgExtended[];
+} & OrgsExtra & SubscriptionMapWithSubscription<OrgExtended>;
+
+
+export function handleOrgsBeforeSubscribe(orgs: Orgs) {
+	orgs.null = {
+		_id: null,
+		title: "",
+		isOrg: true,
+		users: Object.assign(new Set<User>(), { sorted: [] })
+	};
+	
+}
+
+/** @this UsersSubscriptionGroup */
+export function handleOrgs(this: UsersSubscriptionGroup, updated: null | SubscriptionMapUpdated<Org>) {
+	if (updated)
+		for (const org of updated.added) {
+			org.isOrg = true;
+			
+			org.users = Object.assign(new Set<User>(), { sorted: [] });
+		}
+	else {
+		this.values.orgs.null.users.clear();
+		this.values.orgs.null.users.sorted.length = 0;
+	}
+	
+}
+
+/** @this UsersSubscriptionGroup */
+export function handleExtendedOrgs(this: UsersSubscriptionGroup, updated: null | SubscriptionMapUpdated<OrgExtension>) {
+	
+	const orgs = this.values.orgs as OrgsExtended;
+	
+	if (updated) {
+		const { users, extendedOrgs } = this.values;
+		
+		for (const orgExtension of updated) {
+			const org = orgs.get(orgExtension._id)!;
+			
+			org.owners = orgExtension.owners.map(_id => users.get(_id) || orgs.get(_id));
+			org.slaveOrgs = getAll(orgs, orgExtension.slaveOrgs, true);
+			org.note = orgExtension.note;
+			org._l = 0;
+		}
+		
+		const sortedHierarchically = [];
+		
+		for (const orgExtension of extendedOrgs.sorted) {
+			const org = orgs.get(orgExtension._id)!;
+			
+			for (const slaveOrg of org.slaveOrgs!)
+				slaveOrg._l = org._l! + 1;
+			
+			sortedHierarchically.push(org);
+		}
+		
+		orgs.sortedHierarchically = sortedHierarchically;
+		
+		if (this.isLoaded) {
+			this.items.users.emitUpdate();
+			this.items.orgs.emitUpdate(updated);
+		}
+	} else {
+		for (const org of orgs.sorted) {
+			delete org.owners;
+			delete org.slaveOrgs;
+			delete org.note;
+			delete org._l;
+		}
+		delete orgs.sortedHierarchically;
+	}
+	
+}

package/src/roles.ts

@@ -0,0 +1,35 @@
+import { getAll } from "@nesvet/n";
+import type { SubscriptionMapUpdated, SubscriptionMapWithSubscription } from "insite-subscriptions-client";
+import type { UsersSubscriptionGroup } from "./UsersSubscriptionGroup";
+
+
+export type Role = {
+	_id: string;
+	ownInvolves: Role[];
+	involves: Role[];
+	_l: number;
+};
+
+export type Roles = SubscriptionMapWithSubscription<Role>;
+
+
+/** @this UsersSubscriptionGroup */
+export function handleRoles(this: UsersSubscriptionGroup, updated: null | SubscriptionMapUpdated<Role>) {
+	if (updated) {
+		const roles = this.values.roles as Roles;
+		
+		for (const role of updated) {
+			role.ownInvolves = getAll(roles, role.ownInvolves as unknown as string[], true);
+			role.involves = getAll(roles, role.involves as unknown as string[], true);
+			role._l = 0;
+		}
+		
+		for (const role of roles.sorted)
+			for (const involvedRole of role.ownInvolves)
+				involvedRole._l = role._l + 1;
+		
+		if (this.isLoaded)
+			this.items.users.emitUpdate(updated);
+	}
+	
+}

package/{lib/user.js → src/user.ts}

@@ -1,5 +1,22 @@
+import type { Abilities, AbilitiesSchema } from "insite-common";
+import type { Org } from "./orgs";
+import type { User, UserExtended } from "./users";
+import type { UsersSubscriptionGroup } from "./UsersSubscriptionGroup";
+
+
+export type CurrentUser<AS extends AbilitiesSchema = AbilitiesSchema> = {
+	abilities: Abilities<AS>;
+	sessionId?: string;
+	slaveIds: string[];
+	slavesSnapshot: string;
+	slaves: (Org | User)[];
+	slaveUsers: User[];
+	slaveOrgs: Org[];
+} & UserExtended;
+
+
 /** @this UsersSubscriptionGroup */
-export function handleUser(user) {
+export function handleUser(this: UsersSubscriptionGroup, user: CurrentUser) {
 	if (user) {
 		
 		const slavesSnapshot = user.slaveIds.join(",");

package/src/users.ts

@@ -0,0 +1,125 @@
+import { removeOne } from "@nesvet/n";
+import type { SubscriptionMapUpdated, SubscriptionMapWithSubscription } from "insite-subscriptions-client";
+import type { NullOrg, Org, Orgs } from "./orgs";
+import type { Role } from "./roles";
+import type { CurrentUser } from "./user";
+import type { UsersSubscriptionGroup } from "./UsersSubscriptionGroup";
+
+
+export type User = {
+	_id: string;
+	isUser: true;
+	email: string;
+	name: {
+		first: string;
+		middle: string;
+		last: string;
+	};
+	orgId: string;
+	job: string;
+	initials: string;
+	displayLabel: string;
+	avatarUrl: string;
+	isOnline: boolean;
+	org: NullOrg | Org;
+};
+
+type UserExtension = {
+	_id: string;
+	roleIds: string[];
+};
+
+export type UserExtended = {
+	roles?: Role;
+} & User;
+
+export type Users = SubscriptionMapWithSubscription<User>;
+
+export type UsersExtended = SubscriptionMapWithSubscription<UserExtended>;
+
+
+/** @this UsersSubscriptionGroup */
+export function handleUsers(this: UsersSubscriptionGroup, updated: null | SubscriptionMapUpdated<User>) {
+	if (updated) {
+		const users = this.values.users as Users;
+		const currentUser = this.values.user as CurrentUser;
+		const orgs = this.values.orgs as Orgs;
+		
+		if (users.get(currentUser._id) !== currentUser) {
+			users.set(currentUser._id, currentUser);
+			users.sorted[users.sorted.findIndex(user => user._id === currentUser._id)] = currentUser;
+		}
+		const updatedUserIndex = updated.findIndex(user => user._id === currentUser._id);
+		
+		if (~updatedUserIndex)
+			updated[updatedUserIndex] = currentUser;
+		
+		const addedUserIndex = updated.added.findIndex(user => user._id === currentUser._id);
+		
+		if (~addedUserIndex)
+			updated.added[updatedUserIndex] = currentUser;
+		
+		for (const user of updated.added)
+			user.isUser = true;
+		
+		let shouldUpdateUser;
+		const orgsToSortUsers = new Set<NullOrg | Org>();
+		
+		for (const user of updated) {
+			const org = orgs.get(user.orgId) ?? orgs.null;
+			
+			if (user.org !== org) {
+				if (user.org) {
+					user.org.users.delete(user);
+					removeOne(user.org.users.sorted, user);
+				}
+				user.org = org;
+				user.org.users.add(user);
+				user.org.users.sorted.push(user);
+				
+				orgsToSortUsers.add(user.org);
+			}
+			
+			if (user === currentUser)
+				shouldUpdateUser = true;
+			
+		}
+		
+		for (const org of orgsToSortUsers)
+			org.users.sorted.sort(users.sortCompareFunction!);
+		
+		if (updated.deleted.length)
+			for (const org of [ ...orgs.sorted, orgs.null ])
+				for (const user of org.users)
+					if (!users.has(user._id)) {
+						org.users.delete(user);
+						removeOne(org.users.sorted, user);
+					}
+		
+		if (this.isLoaded) {
+			if (shouldUpdateUser)
+				this.items.user.emitUpdate();
+			this.items.orgs.emitUpdate();
+		}
+	}
+	
+}
+
+/** @this UsersSubscriptionGroup */
+export function handleExtendedUsers(this: UsersSubscriptionGroup, updated: null | SubscriptionMapUpdated<UserExtension>) {
+	
+	const users = this.values.users as UsersExtended;
+	
+	if (updated) {
+		const { roles } = this.values;
+		
+		for (const userExtension of updated) {
+			const user = users.get(userExtension._id)!;
+			
+			user.roles = roles.getAll(userExtension.roleIds);
+		}
+	} else
+		for (const user of users.sorted)
+			delete user.roles;
+	
+}

package/lib/UsersSubscriptionGroup.js

@@ -1,57 +0,0 @@
-import { SubscriptionGroup } from "insite-subscriptions-client";
-import { handleExtendedOrgs, handleOrgs, handleOrgsBeforeSubscribe } from "./orgs";
-import { handleRoles } from "./roles";
-import { handleUser } from "./user";
-import { handleExtendedUsers, handleUsers } from "./users";
-
-
-export class UsersSubscriptionGroup extends SubscriptionGroup {
-	constructor(options) {
-		super([
-			[ "orgs", "map", handleOrgs, handleOrgsBeforeSubscribe ],
-			[ "users", "map", handleUsers ],
-			[ "user", [ true ], handleUser ]
-		], options);
-		
-	}
-	
-	isExtended = false;
-	
-	extend() {
-		
-		if (this.isExtended === false) {
-			this.isExtended = null;
-			
-			return this.attach([
-				[ "roles", "map", handleRoles ],
-				[ "extendedUsers", "map", "users.extended", handleExtendedUsers, true ],
-				[ "extendedOrgs", "map", "orgs.extended", handleExtendedOrgs, true ]
-			]).then(() => {
-				
-				this.isExtended = true;
-				
-			});
-		}
-		
-	}
-	
-	unextend() {
-		
-		if (this.isExtended) {
-			this.isExtended = false;
-			
-			this.detach([ "roles", "extendedUsers", "extendedOrgs" ]);
-		}
-		
-	}
-	
-	
-	static handleValues({ orgs, users, user }, options) {
-		return new SubscriptionGroup([
-			[ "orgs", orgs, handleOrgs, handleOrgsBeforeSubscribe ],
-			[ "users", users, handleUsers ],
-			[ "user", user, handleUser ]
-		], options);
-	}
-	
-}

package/lib/index.js

@@ -1 +0,0 @@
-export * from "./UsersSubscriptionGroup";

package/lib/orgs.js

@@ -1,72 +0,0 @@
-export function handleOrgsBeforeSubscribe(orgs) {
-	
-	orgs.null = {
-		_id: null,
-		title: "",
-		isOrg: true,
-		users: Object.assign(new Set(), { sorted: [] })
-	};
-	
-}
-
-/** @this UsersSubscriptionGroup */
-export function handleOrgs(updated) {
-	if (updated)
-		for (const org of updated.added) {
-			org.isOrg = true;
-			
-			org.users = Object.assign(new Set(), { sorted: [] });
-		}
-	else {
-		const nullOrgUsers = this.values.orgs.null.users;
-		nullOrgUsers.clear();
-		nullOrgUsers.sorted.length = 0;
-	}
-	
-}
-
-/** @this UsersSubscriptionGroup */
-export function handleExtendedOrgs(updated) {
-	
-	const { orgs } = this.values;
-	
-	if (updated) {
-		const { users, extendedOrgs } = this.values;
-		
-		for (const orgDoc of updated) {
-			const org = orgs.get(orgDoc._id);
-			
-			org.owners = orgDoc.owners.map(_id => users.get(_id) || orgs.get(_id));
-			org.slaveOrgs = orgs.getAll(orgDoc.slaveOrgs);
-			org.note = orgDoc.note;
-			org._l = 0;
-		}
-		
-		const sortedHierarchically = [];
-		
-		for (const orgDoc of extendedOrgs.sorted) {
-			const org = orgs.get(orgDoc._id);
-			
-			for (const slaveOrg of org.slaveOrgs)
-				slaveOrg._l = org._l + 1;
-			
-			sortedHierarchically.push(org);
-		}
-		
-		orgs.sortedHierarchically = sortedHierarchically;
-		
-		if (this.isLoaded) {
-			this.items.users.emitUpdate();
-			this.items.orgs.emitUpdate(updated);
-		}
-	} else {
-		for (const org of orgs.sorted) {
-			delete org.owners;
-			delete org.slaveOrgs;
-			delete org.note;
-			delete org._l;
-		}
-		delete orgs.sortedHierarchically;
-	}
-	
-}

package/lib/roles.js

@@ -1,20 +0,0 @@
-/** @this UsersSubscriptionGroup */
-export function handleRoles(updated) {
-	if (updated) {
-		const { roles } = this.values;
-		
-		for (const role of updated) {
-			role.ownInvolves = roles.getAll(role.ownInvolves);
-			role.involves = roles.getAll(role.involves);
-			role._l = 0;
-		}
-		
-		for (const role of roles.sorted)
-			for (const involvedRole of role.ownInvolves)
-				involvedRole._l = role._l + 1;
-		
-		if (this.isLoaded)
-			this.items.users.emitUpdate(updated);
-	}
-	
-}

package/lib/users.js

@@ -1,83 +0,0 @@
-/** @this UsersSubscriptionGroup */
-export function handleUsers(updated) {
-	if (updated) {
-		const { users, user: currentUser, orgs } = this.values;
-		
-		if (users.get(currentUser._id) !== currentUser) {
-			users.set(currentUser._id, currentUser);
-			users.sorted[users.sorted.findIndex(user => user._id === currentUser._id)] = currentUser;
-		}
-		const updatedUserIndex = updated.findIndex(user => user._id === currentUser._id);
-		
-		if (~updatedUserIndex)
-			updated[updatedUserIndex] = currentUser;
-		
-		const addedUserIndex = updated.added.findIndex(user => user._id === currentUser._id);
-		
-		if (~addedUserIndex)
-			updated.added[updatedUserIndex] = currentUser;
-		
-		for (const user of updated.added)
-			user.isUser = true;
-		
-		let shouldUpdateUser;
-		const orgsToSortUsers = new Set();
-		
-		for (const user of updated) {
-			const org = orgs.get(user.orgId) ?? orgs.null;
-			
-			if (user.org !== org) {
-				if (user.org) {
-					user.org.users.delete(user);
-					user.org.users.sorted.remove(user);
-				}
-				user.org = org;
-				user.org.users.add(user);
-				user.org.users.sorted.push(user);
-				
-				orgsToSortUsers.add(user.org);
-			}
-			
-			if (user === currentUser)
-				shouldUpdateUser = true;
-			
-		}
-		
-		for (const org of orgsToSortUsers)
-			org.users.sorted.sort(users.sortCompareFunction);
-		
-		if (updated.deleted.length)
-			for (const org of orgs.sorted)
-				for (const user of org.users)
-					if (!users.has(user._id)) {
-						org.users.delete(user);
-						org.users.sorted.remove(user);
-					}
-		
-		if (this.isLoaded) {
-			if (shouldUpdateUser)
-				this.items.user.emitUpdate();
-			this.items.orgs.emitUpdate();
-		}
-	}
-	
-}
-
-/** @this UsersSubscriptionGroup */
-export function handleExtendedUsers(updated) {
-	
-	const { users } = this.values;
-	
-	if (updated) {
-		const { roles } = this.values;
-		
-		for (const userDoc of updated) {
-			const user = users.get(userDoc._id);
-			
-			user.roles = roles.getAll(userDoc.roleIds);
-		}
-	} else
-		for (const user of users.sorted)
-			delete user.roles;
-	
-}