@webitel/ui-sdk 26.8.112 → 26.8.114

package/dist/{wt-vidstack-player-u4R9q51f.js → wt-vidstack-player-C_EdEZ8v.js}

@@ -1,9 +1,9 @@
-import { w as e } from "./components-GY1xFZWr.js";
-import "./convertDuration-heRoQzks.js";
+import { w as e } from "./components-DJVzkzrr.js";
+import "./convertDuration-BOe9PsRT.js";
 import { t } from "./_plugin-vue_export-helper-B3ysoDQm.js";
-import { c as n } from "./enums-BDtfwdQu.js";
-import "./wt-button-BmBqpEkp.js";
-import { t as r } from "./wt-icon-btn-C8xuTCJR.js";
+import { m as n } from "./enums-CsINFPBu.js";
+import "./wt-button-rUZKbswL.js";
+import { t as r } from "./wt-icon-btn-D3lG7Acn.js";
 import { $ as i, C as a, D as o, F as s, G as c, H as l, I as u, J as d, K as f, L as p, M as m, N as h, O as g, P as ee, Q as _, R as te, S as v, U as ne, V as y, W as b, X as x, Y as re, Z as S, _ as C, a as ie, b as ae, c as oe, d as se, et as ce, f as le, g as ue, h as de, i as w, it as fe, j as pe, k as me, l as T, m as he, n as E, nt as D, o as O, ot as ge, p as k, q as A, r as j, rt as _e, t as ve, tt as ye, u as be, v as M, w as xe, y as Se, z as Ce } from "./vidstack-D9mvYVIz-DesuYgKV.js";
 import { _ as N, a as we, c as Te, d as Ee, f as De, g as Oe, h as ke, i as Ae, l as je, m as Me, n as Ne, o as Pe, p as Fe, r as Ie, s as Le, t as P, u as Re } from "./vidstack-CgfrU1hS-CNTJkyzm.js";
 import { _ as ze, a as Be, c as Ve, f as He, g as Ue, h as We, i as Ge, l as Ke, n as qe, r as Je, s as Ye, t as Xe, u as Ze, v as Qe, x as $e, y as et } from "./useVidstackSrc-aQcqC_v0.js";
@@ -14,7 +14,7 @@ import { a as at, i as ot, n as L, o as st, r as R, t as ct } from "./vidstack-D
 import { t as z } from "./vidstack-_E7LrUjK-DaCLs8ge.js";
 import { n as lt, t as ut } from "./vidstack-CDOoBnJL-BCwLE1fB.js";
 import { i as dt, n as ft, r as pt, t as mt } from "./vidstack-CdfyZegh-Bn47J4h6.js";
-import { t as ht } from "./wt-slider-Co6hZQu_.js";
+import { t as ht } from "./wt-slider-x-Tch7RT.js";
 import { computed as gt, createBlock as _t, createCommentVNode as vt, createElementBlock as yt, createElementVNode as bt, createSlots as xt, createVNode as B, defineComponent as St, inject as Ct, normalizeClass as wt, onBeforeUnmount as Tt, onMounted as Et, openBlock as V, provide as Dt, ref as Ot, renderSlot as H, resolveComponent as kt, toDisplayString as At, toRefs as jt, unref as U, useTemplateRef as Mt, withCtx as Nt } from "vue";
 //#region node_modules/vidstack/prod/chunks/vidstack-CYE89tBD.js
 var Pt = he();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/ui-sdk",
-	"version": "26.8.112",
+	"version": "26.8.114",
 	"private": false,
 	"scripts": {
 		"dev": "npm run docs:dev",

package/src/components/on-demand/wt-type-extension-value-input/wt-type-extension-value-input.vue

@@ -32,10 +32,8 @@
     }"
   >
     <wt-single-select
-      v-bind="sharedChildrenProps"
+      v-bind="{ ...sharedChildrenProps, ...selectProps }"
       :model-value="value"
-      :search-method="loadLookupList(field.lookup)"
-      data-key="id"
       @update:model-value="selectElement"
     />
   </slot>
@@ -86,8 +84,12 @@ import {
 import { computed } from 'vue';
 import { useI18n } from 'vue-i18n';
 
-import { WtTypeExtensionFieldKind as FieldType } from '../../../enums';
+import {
+	WtTypeExtensionFieldKind as FieldType,
+	type WtObject,
+} from '../../../enums';
 import type { VuelidateFieldLike } from '../../../mixins/validationMixin/vuelidate/useVuelidateValidation';
+import { useLookupFieldReadAccess } from '../../../modules/Userinfo';
 
 const model = defineModel<unknown>();
 
@@ -95,6 +97,8 @@ const props = defineProps<{
 	field: DataField;
 	label?: string;
 	required?: boolean;
+	disabled?: boolean;
+	hasReadAccess?: (object?: WtObject) => boolean;
 	/**
 	 * TODO: implement validation
 	 */
@@ -111,6 +115,11 @@ const props = defineProps<{
 
 const { t } = useI18n();
 
+const { hasReadAccess: hasLookupReadAccess } = useLookupFieldReadAccess(
+	() => props.field,
+	props.hasReadAccess,
+);
+
 const resolvedLabel = computed(() => {
 	return props.label || t(props.field?.name || 'vocabulary.labels');
 });
@@ -119,6 +128,8 @@ const isRequired = computed(() => {
 	return props.required ?? props.field.required;
 });
 
+const isDisabled = computed(() => props.disabled || !hasLookupReadAccess.value);
+
 // biome-ignore lint/suspicious/noExplicitAny: the value type follows `field.kind` at runtime
 const value = computed<any>(() => {
 	return model.value;
@@ -127,6 +138,7 @@ const value = computed<any>(() => {
 const sharedChildrenProps = computed(() => ({
 	label: resolvedLabel.value,
 	required: isRequired.value,
+	disabled: isDisabled.value,
 	v: props.v,
 }));
 
@@ -139,7 +151,9 @@ const sharedChildrenProps = computed(() => ({
 const selectProps = computed(() => ({
 	clearable: true,
 	dataKey: 'id',
-	searchMethod: loadLookupList(props.field.lookup),
+	searchMethod: hasLookupReadAccess.value
+		? loadLookupList(props.field.lookup)
+		: undefined,
 }));
 
 const multiselectProps = computed(() => ({

package/src/modules/Userinfo/composables/useLookupFieldReadAccess.ts

@@ -0,0 +1,54 @@
+import { computed, type MaybeRefOrGetter, type Ref, toValue } from 'vue';
+
+import type { WtObject } from '../../../enums';
+import { injectFilterReadAccess } from '../injection/filterReadAccess';
+import {
+	getScopeClassByLookupPath,
+	getWtObjectByScopeClass,
+} from '../mappings/lookupPathToScopeClass';
+import {
+	normalizeLookupPath,
+	peekTypeObjectClass,
+} from '../scripts/typeObjectClass';
+
+export type LookupFieldHasReadAccess = (object?: WtObject) => boolean;
+
+type LookupField = {
+	lookup?: {
+		path?: string;
+		objclass?: string;
+	};
+};
+
+export const hasLookupFieldReadAccess = (
+	field?: LookupField | null,
+	hasReadAccess?: LookupFieldHasReadAccess,
+): boolean => {
+	const path = normalizeLookupPath(field?.lookup?.path);
+	if (!path) return true;
+
+	const objectClass =
+		field?.lookup?.objclass ||
+		getScopeClassByLookupPath(path) ||
+		peekTypeObjectClass(path);
+	if (!objectClass) return false;
+
+	const wtObject = getWtObjectByScopeClass(objectClass);
+	return hasReadAccess?.(wtObject ?? (objectClass as WtObject)) ?? false;
+};
+
+export const useLookupFieldReadAccess = (
+	field: MaybeRefOrGetter<LookupField | null | undefined>,
+	hasReadAccessFn?: LookupFieldHasReadAccess,
+): {
+	hasReadAccess: Ref<boolean>;
+} => {
+	const getInjected = injectFilterReadAccess();
+	const hasReadAccess = computed(() =>
+		hasLookupFieldReadAccess(toValue(field), hasReadAccessFn ?? getInjected()),
+	);
+
+	return {
+		hasReadAccess,
+	};
+};

package/src/modules/Userinfo/index.ts

@@ -1,5 +1,9 @@
 export { default as ApplicationsAccess } from './classes/ApplicationsAccess';
 export { createUserAccessControlComposable } from './composables/createUserAccessControl';
+export {
+	hasLookupFieldReadAccess,
+	useLookupFieldReadAccess,
+} from './composables/useLookupFieldReadAccess';
 
 export {
 	CrudGlobalAction,
@@ -7,4 +11,10 @@ export {
 	SpecialGlobalAction,
 	WebitelLicense,
 } from './enums';
+export {
+	type FilterHasReadAccess,
+	FilterReadAccessKey,
+	injectFilterReadAccess,
+	provideFilterReadAccess,
+} from './injection/filterReadAccess';
 export { createUserinfoStore } from './stores/userinfoStore';

package/src/modules/Userinfo/injection/filterReadAccess.ts

@@ -0,0 +1,21 @@
+import type { InjectionKey } from 'vue';
+import { inject, provide } from 'vue';
+
+import type { WtObject } from '../../../enums';
+
+export type FilterHasReadAccess = (object?: WtObject) => boolean;
+
+/** Getter around the checker: `provide` would call a bare function as a factory. */
+export const FilterReadAccessKey: InjectionKey<
+	() => FilterHasReadAccess | undefined
+> = Symbol('filterReadAccess');
+
+export const provideFilterReadAccess = (
+	getHasReadAccess: () => FilterHasReadAccess | undefined,
+) => {
+	const parent = inject(FilterReadAccessKey, undefined);
+	provide(FilterReadAccessKey, () => getHasReadAccess() ?? parent?.());
+};
+
+export const injectFilterReadAccess = () =>
+	inject(FilterReadAccessKey, () => undefined);

package/src/modules/Userinfo/mappings/lookupPathToScopeClass.ts

@@ -0,0 +1,53 @@
+import { ScopeClass } from '../enums';
+import { mapScopeClassToWtObjects } from './mappings';
+
+/**
+ * Needed to resolve lookup Read access: checks use WtObject, but `lookup.path`
+ * is a type-registry path (`call_center/queues`) and often has no `objclass`.
+ * This table maps path → ScopeClass; `mapScopeClassToWtObjects` then gives
+ * WtObject. Paths not listed here go through `/types/{path}`.
+ */
+
+const lookupPathToScopeClass: Partial<Record<string, ScopeClass>> = {
+	'call_center/queues': ScopeClass.Queue,
+	'call_center/agents': ScopeClass.Agent,
+	'call_center/list': ScopeClass.List,
+	'call_center/teams': ScopeClass.Team,
+	'call_center/skills': ScopeClass.Skills,
+	'contacts/groups': ScopeClass.ContactGroups,
+};
+
+/** Nested type-registry paths, e.g. `cases/priorities`. */
+const lookupPathPrefixToScopeClass: Array<{
+	prefix: string;
+	scopeClass: ScopeClass;
+}> = [
+	{
+		prefix: 'cases/',
+		scopeClass: ScopeClass.CaseLookups,
+	},
+	{
+		prefix: 'dictionaries/',
+		scopeClass: ScopeClass.Custom,
+	},
+];
+
+export const getScopeClassByLookupPath = (path?: string) => {
+	if (!path) return undefined;
+
+	if (mapScopeClassToWtObjects[path as ScopeClass]) {
+		return path as ScopeClass;
+	}
+
+	const exact = lookupPathToScopeClass[path];
+	if (exact) return exact;
+
+	return lookupPathPrefixToScopeClass.find(({ prefix }) =>
+		path.startsWith(prefix),
+	)?.scopeClass;
+};
+
+export const getWtObjectByScopeClass = (objectClass?: string) =>
+	objectClass
+		? mapScopeClassToWtObjects[objectClass as ScopeClass]?.[0]
+		: undefined;

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;
+	}
+}