@webitel/ui-sdk 26.8.111 → 26.8.113

package/src/modules/Userinfo/scripts/typeObjectClass.ts

@@ -0,0 +1,55 @@
+import { ObjectsAPI } from '@webitel/api-services/api';
+import type { ProtoDataStruct } from '@webitel/api-services/gen-wire/models';
+import { reactive } from 'vue';
+
+/**
+ * Type-registry `lookup.path` often has no RBAC class on the field itself.
+ * `/types/{path}` returns `objclass`; we cache it so lookup Read checks can
+ * fail closed while the request is in flight and re-enable when it lands.
+ */
+const objectClassByPath = reactive(new Map<string, string | undefined>());
+const inflightByPath = new Map<string, Promise<string | undefined>>();
+
+export const normalizeLookupPath = (path?: string) =>
+	path?.replace(/^\//, '') || undefined;
+
+const fetchTypeObjectClass = async (
+	path: string,
+): Promise<string | undefined> => {
+	if (objectClassByPath.has(path)) {
+		return objectClassByPath.get(path);
+	}
+
+	const inflight = inflightByPath.get(path);
+	if (inflight) return inflight;
+
+	const request = ObjectsAPI.get({
+		itemId: path,
+	})
+		.then((type: ProtoDataStruct) => {
+			const objectClass = type?.objclass;
+			objectClassByPath.set(path, objectClass);
+			return objectClass;
+		})
+		.catch(() => {
+			objectClassByPath.set(path, undefined);
+			return undefined;
+		})
+		.finally(() => {
+			inflightByPath.delete(path);
+		});
+
+	inflightByPath.set(path, request);
+	return request;
+};
+
+export const peekTypeObjectClass = (path?: string) => {
+	const normalized = normalizeLookupPath(path);
+	if (!normalized) return undefined;
+
+	if (!objectClassByPath.has(normalized)) {
+		void fetchTypeObjectClass(normalized);
+	}
+
+	return objectClassByPath.get(normalized);
+};

package/src/modules/Userinfo/stores/userinfoStore.ts

@@ -1,11 +1,17 @@
 import { pick } from 'lodash-es';
 import { defineStore, storeToRefs } from 'pinia';
 import { ref } from 'vue';
+
+import type { WtObject } from '../../../enums';
 import { createUserNotificationsStore } from '../../UserNotifications/stores/userNotificationsStore';
 import { getSession, getUiVisibilityAccess, logout } from '../api/UserinfoAPI';
 import { createUserAccessStore } from './accessStore';
 import { createSettingsStore } from './settingsStore';
 
+type UserinfoStoreApi = {
+	hasReadAccess: (object?: WtObject) => boolean;
+};
+
 export const createUserinfoStore = () => {
 	const namespace = 'userinfo';
 	const useAccessStore = createUserAccessStore({
@@ -106,8 +112,13 @@ export const createUserinfoStore = () => {
 		};
 	});
 
-	// @ts-expect-error
-	window._userinfoStore = store;
+	window._userinfoStore = store as Window['_userinfoStore'];
 
 	return store;
 };
+
+declare global {
+	interface Window {
+		_userinfoStore?: () => UserinfoStoreApi;
+	}
+}

package/src/scripts/__tests__/{sortQueryAdapters.spec.js → sortQueryAdapters.spec.ts}

@@ -1,4 +1,4 @@
-import * as sortQueryAdapters from '../sortQueryAdapters.js';
+import * as sortQueryAdapters from '../sortQueryAdapters';
 
 test('sortToQueryAdapter', () => {
 	expect(sortQueryAdapters.sortToQueryAdapter('asc')).toBe('+');
@@ -10,3 +10,8 @@ test('queryToSortAdapter', () => {
 	expect(sortQueryAdapters.queryToSortAdapter('-')).toBe('desc');
 	expect(sortQueryAdapters.queryToSortAdapter('')).toBe(null);
 });
+test('getNextSortOrder', () => {
+	expect(sortQueryAdapters.getNextSortOrder('asc')).toBe('desc');
+	expect(sortQueryAdapters.getNextSortOrder('desc')).toBe(null);
+	expect(sortQueryAdapters.getNextSortOrder(null)).toBe('asc');
+});

package/src/scripts/sortQueryAdapters.ts

@@ -0,0 +1,45 @@
+export const SortSymbols = Object.freeze({
+	ASC: 'asc',
+	DESC: 'desc',
+	NONE: null,
+} as const);
+
+export type SortOrder = (typeof SortSymbols)[keyof typeof SortSymbols];
+
+// query-string prefix the API sorts by: `+field` ascending, `-field` descending
+export type SortQueryPrefix = '+' | '-' | '';
+
+export const sortToQueryAdapter = (order?: SortOrder): SortQueryPrefix => {
+	switch (order) {
+		case SortSymbols.ASC:
+			return '+';
+		case SortSymbols.DESC:
+			return '-';
+		default:
+			return '';
+	}
+};
+
+export const queryToSortAdapter = (order?: string): SortOrder => {
+	switch (order) {
+		case '+':
+			return SortSymbols.ASC;
+		case '-':
+			return SortSymbols.DESC;
+		default:
+			return SortSymbols.NONE;
+	}
+};
+
+// cycles a column through asc -> desc -> none -> asc; a boolean `sort` is the
+// back-compat "sortable, not sorted yet" header flag and starts at asc
+export const getNextSortOrder = (sort?: SortOrder | boolean): SortOrder => {
+	switch (sort) {
+		case SortSymbols.ASC:
+			return SortSymbols.DESC;
+		case SortSymbols.DESC:
+			return SortSymbols.NONE;
+		default:
+			return SortSymbols.ASC;
+	}
+};

package/src/store/new/modules/tableStoreModule/__tests__/tableStoreModule.spec.js

@@ -3,7 +3,7 @@ import { createStore } from 'vuex';
 
 import FilterEvent from '../../../../../modules/Filters/enums/FilterEvent.enum.js';
 import FiltersStoreModule from '../../../../../modules/Filters/store/FiltersStoreModule.js';
-import { SortSymbols } from '../../../../../scripts/sortQueryAdapters.js';
+import { SortSymbols } from '../../../../../scripts/sortQueryAdapters';
 import { createTableStoreModule } from '../../../helpers/createTableStoreModule.js';
 
 describe('TableStoreModule', () => {

package/src/store/new/modules/tableStoreModule/tableStoreModule.js

@@ -2,7 +2,7 @@ import FilterEvent from '../../../../modules/Filters/enums/FilterEvent.enum.js';
 import {
 	queryToSortAdapter,
 	sortToQueryAdapter,
-} from '../../../../scripts/sortQueryAdapters.js';
+} from '../../../../scripts/sortQueryAdapters';
 
 const state = () => ({
 	headers: [],