@j2inn/resolvable-ui-elements 2.0.0 → 2.1.1-beta.0

package/dist_es/resolvableElements/Resolver.d.ts

@@ -1,47 +1,47 @@
-import { HDict, HGrid } from 'haystack-core';
-import { Client, Watch } from 'haystack-nclient';
-export declare const DEFAULT_USER_ROLE_TAG_NAME = "uiElementPermissions";
-export interface ResolverData {
-    /**
-     * Haystack client for network communication
-     */
-    client: Client;
-    /**
-     * Current user dict, used to check permissions
-     */
-    user?: HDict;
-    /**
-     * Name of the tag that is expected on the user dict to define its role
-     */
-    userRoleTagName?: string;
-    /**
-     * Function name to be used for expressions eval,
-     * used to enable custom backend permission check using elements path
-     * @example
-     * customEval(\`page/section/elementName\`, parametersDict)
-     */
-    evalFuncName?: string;
-}
-/**
- * Resolver is a mediator for the network interactions during the resolution process,
- * in order to enable future optimizations and extra features
- */
-export declare class Resolver implements ResolverData {
-    constructor({ client, user, userRoleTagName, evalFuncName, }: ResolverData);
-    client: Client;
-    user?: HDict;
-    userRoleTagName?: string;
-    evalFuncName?: string;
-    read(filter: string): Promise<HGrid<HDict>>;
-    makeWatch(dis: string, grid: HGrid<HDict>): Promise<Watch>;
-    /**
-     * Eval an expression using either the provided path or otherwse directly the expression
-     * Providing the path allows for whitelisting of certain functions to specific user roles
-     */
-    evalExprElement(expr: string, parameters: HDict, path?: string): Promise<HGrid<HDict>>;
-    private _buildExpression;
-    /**
-     * Evaluate an expression
-     */
-    private _eval;
-}
+import { HDict, HGrid } from 'haystack-core';
+import { Client, Watch } from 'haystack-nclient';
+export declare const DEFAULT_USER_ROLE_TAG_NAME = "uiElementPermissions";
+export interface ResolverData {
+    /**
+     * Haystack client for network communication
+     */
+    client: Client;
+    /**
+     * Current user dict, used to check permissions
+     */
+    user?: HDict;
+    /**
+     * Name of the tag that is expected on the user dict to define its role
+     */
+    userRoleTagName?: string;
+    /**
+     * Function name to be used for expressions eval,
+     * used to enable custom backend permission check using elements path
+     * @example
+     * customEval(\`page/section/elementName\`, parametersDict)
+     */
+    evalFuncName?: string;
+}
+/**
+ * Resolver is a mediator for the network interactions during the resolution process,
+ * in order to enable future optimizations and extra features
+ */
+export declare class Resolver implements ResolverData {
+    constructor({ client, user, userRoleTagName, evalFuncName, }: ResolverData);
+    client: Client;
+    user?: HDict;
+    userRoleTagName?: string;
+    evalFuncName?: string;
+    read(filter: string): Promise<HGrid<HDict>>;
+    makeWatch(dis: string, grid: HGrid<HDict>): Promise<Watch>;
+    /**
+     * Eval an expression using either the provided path or otherwse directly the expression
+     * Providing the path allows for whitelisting of certain functions to specific user roles
+     */
+    evalExprElement(expr: string, parameters: HDict, path?: string): Promise<HGrid<HDict>>;
+    private _buildExpression;
+    /**
+     * Evaluate an expression
+     */
+    private _eval;
+}

package/dist_es/resolvableElements/Resolver.js

@@ -1,54 +1,54 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { HUri } from 'haystack-core';
-import { resolveTemplateExpression } from './resolveTemplatedExpression';
-export const DEFAULT_USER_ROLE_TAG_NAME = 'uiElementPermissions';
-/**
- * Resolver is a mediator for the network interactions during the resolution process,
- * in order to enable future optimizations and extra features
- */
-export class Resolver {
-    constructor({ client, user, userRoleTagName = DEFAULT_USER_ROLE_TAG_NAME, evalFuncName, }) {
-        this.client = client;
-        this.user = user;
-        this.userRoleTagName = userRoleTagName;
-        this.evalFuncName = evalFuncName;
-    }
-    client;
-    user;
-    userRoleTagName;
-    evalFuncName;
-    read(filter) {
-        return this.client.ext.read(filter);
-    }
-    makeWatch(dis, grid) {
-        return this.client.ops.watch.make(dis, grid);
-    }
-    /**
-     * Eval an expression using either the provided path or otherwse directly the expression
-     * Providing the path allows for whitelisting of certain functions to specific user roles
-     */
-    evalExprElement(expr, parameters, path) {
-        return this._eval(this._buildExpression(expr, parameters, path));
-    }
-    _buildExpression(expr, parameters, path) {
-        if (!!path && this.evalFuncName) {
-            return `${this.evalFuncName}(${HUri.make(path).toAxon()}, ${parameters.toAxon()})`;
-        }
-        else {
-            return resolveTemplateExpression(expr, parameters);
-        }
-    }
-    /**
-     * Evaluate an expression
-     */
-    async _eval(expr) {
-        const grid = await this.client.ext.eval(expr);
-        if (grid.isError()) {
-            console.error('Empty grid result for expression: \n', expr, grid.getError());
-        }
-        return grid;
-    }
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { HUri } from 'haystack-core';
+import { resolveTemplateExpression } from './resolveTemplatedExpression';
+export const DEFAULT_USER_ROLE_TAG_NAME = 'uiElementPermissions';
+/**
+ * Resolver is a mediator for the network interactions during the resolution process,
+ * in order to enable future optimizations and extra features
+ */
+export class Resolver {
+    constructor({ client, user, userRoleTagName = DEFAULT_USER_ROLE_TAG_NAME, evalFuncName, }) {
+        this.client = client;
+        this.user = user;
+        this.userRoleTagName = userRoleTagName;
+        this.evalFuncName = evalFuncName;
+    }
+    client;
+    user;
+    userRoleTagName;
+    evalFuncName;
+    read(filter) {
+        return this.client.ext.read(filter);
+    }
+    makeWatch(dis, grid) {
+        return this.client.ops.watch.make(dis, grid);
+    }
+    /**
+     * Eval an expression using either the provided path or otherwse directly the expression
+     * Providing the path allows for whitelisting of certain functions to specific user roles
+     */
+    evalExprElement(expr, parameters, path) {
+        return this._eval(this._buildExpression(expr, parameters, path));
+    }
+    _buildExpression(expr, parameters, path) {
+        if (!!path && this.evalFuncName) {
+            return `${this.evalFuncName}(${HUri.make(path).toAxon()}, ${parameters.toAxon()})`;
+        }
+        else {
+            return resolveTemplateExpression(expr, parameters);
+        }
+    }
+    /**
+     * Evaluate an expression
+     */
+    async _eval(expr) {
+        const grid = await this.client.ext.eval(expr);
+        if (grid.isError()) {
+            console.error('Empty grid result for expression: \n', expr, grid.getError());
+        }
+        return grid;
+    }
+}
 //# sourceMappingURL=Resolver.js.map

package/dist_es/resolvableElements/elements/ResolvableElement.d.ts

@@ -1,14 +1,14 @@
-import { HDict } from 'haystack-core';
-import { UiElement, UiElementConstructorData, UiElementData } from './UiElement';
-/**
- * base class for elements that can be resolved
- */
-export declare abstract class ResolvableElement<T extends UiElementData> extends UiElement<T> {
-    #private;
-    constructor(data: UiElementConstructorData<T>);
-    initialize: (parameters: HDict) => Promise<void>;
-    protected abstract doInitialize: (parameters: HDict) => Promise<void>;
-    close: () => Promise<void>;
-    protected abstract doClose: () => Promise<void>;
-    abstract getParameterList: () => string[];
-}
+import { HDict } from 'haystack-core';
+import { UiElement, UiElementConstructorData, UiElementData } from './UiElement';
+/**
+ * base class for elements that can be resolved
+ */
+export declare abstract class ResolvableElement<T extends UiElementData> extends UiElement<T> {
+    #private;
+    constructor(data: UiElementConstructorData<T>);
+    initialize: (parameters: HDict) => Promise<void>;
+    protected abstract doInitialize: (parameters: HDict) => Promise<void>;
+    close: () => Promise<void>;
+    protected abstract doClose: () => Promise<void>;
+    abstract getParameterList: () => string[];
+}

package/dist_es/resolvableElements/elements/ResolvableElement.js

@@ -1,26 +1,26 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { UiElement } from './UiElement';
-/**
- * base class for elements that can be resolved
- */
-export class ResolvableElement extends UiElement {
-    constructor(data) {
-        super(data);
-    }
-    #initialized = false;
-    initialize = async (parameters) => {
-        if (this.isAccessAllowed(this._meta) && !this.#initialized) {
-            this.#initialized = true;
-            return await this.doInitialize(parameters);
-        }
-    };
-    close = async () => {
-        if (this.#initialized) {
-            await this.doClose();
-            this.#initialized = false;
-        }
-    };
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { UiElement } from './UiElement';
+/**
+ * base class for elements that can be resolved
+ */
+export class ResolvableElement extends UiElement {
+    constructor(data) {
+        super(data);
+    }
+    #initialized = false;
+    initialize = async (parameters) => {
+        if (this.isAccessAllowed(this._meta) && !this.#initialized) {
+            this.#initialized = true;
+            return await this.doInitialize(parameters);
+        }
+    };
+    close = async () => {
+        if (this.#initialized) {
+            await this.doClose();
+            this.#initialized = false;
+        }
+    };
+}
 //# sourceMappingURL=ResolvableElement.js.map

package/dist_es/resolvableElements/elements/ResolvableValueElement.d.ts

@@ -1,16 +1,16 @@
-import { ResolvableElement } from './ResolvableElement';
-import { UiElementConstructorData, UiElementData, UiElementMeta } from './UiElement';
-export interface ResolvableValueElementMeta extends UiElementMeta {
-    resolutionType: string;
-    resolvedType: string;
-    defaultValue: string;
-}
-export declare const isResolvableValueElement: (element: UiElementData) => element is UiElementData<ResolvableValueElementMeta>;
-export declare const isResolvableValueElementMeta: (meta: UiElementMeta) => meta is ResolvableValueElementMeta;
-/**
- * base class for leaf resolvable elements that are resolved into a value defined by the resolvedType property in the metadata
- */
-export declare abstract class ResolvableValueElement<T extends UiElementData = UiElementData> extends ResolvableElement<T> {
-    #private;
-    constructor(data: UiElementConstructorData<T>);
-}
+import { ResolvableElement } from './ResolvableElement';
+import { UiElementConstructorData, UiElementData, UiElementMeta } from './UiElement';
+export interface ResolvableValueElementMeta extends UiElementMeta {
+    resolutionType: string;
+    resolvedType: string;
+    defaultValue: string;
+}
+export declare const isResolvableValueElement: (element: UiElementData) => element is UiElementData<ResolvableValueElementMeta>;
+export declare const isResolvableValueElementMeta: (meta: UiElementMeta) => meta is ResolvableValueElementMeta;
+/**
+ * base class for leaf resolvable elements that are resolved into a value defined by the resolvedType property in the metadata
+ */
+export declare abstract class ResolvableValueElement<T extends UiElementData = UiElementData> extends ResolvableElement<T> {
+    #private;
+    constructor(data: UiElementConstructorData<T>);
+}

package/dist_es/resolvableElements/elements/ResolvableValueElement.js

@@ -1,33 +1,33 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { ZincReader } from 'haystack-core';
-import { ResolvableElement } from './ResolvableElement';
-export const isResolvableValueElement = (element) => {
-    return !!element?._meta && isResolvableValueElementMeta(element._meta);
-};
-export const isResolvableValueElementMeta = (meta) => {
-    return (!!meta.resolutionType &&
-        !!meta.resolvedType);
-};
-/**
- * base class for leaf resolvable elements that are resolved into a value defined by the resolvedType property in the metadata
- */
-export class ResolvableValueElement extends ResolvableElement {
-    constructor(data) {
-        super(data);
-        this.#setDefaultValue();
-    }
-    #setDefaultValue() {
-        const { defaultValue } = this._meta;
-        if (defaultValue) {
-            try {
-                this.value = ZincReader.readValue(defaultValue);
-            }
-            catch (e) {
-                console.error('Failed to parse element default value from: ', JSON.stringify(this._meta), e);
-            }
-        }
-    }
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { ZincReader } from 'haystack-core';
+import { ResolvableElement } from './ResolvableElement';
+export const isResolvableValueElement = (element) => {
+    return !!element?._meta && isResolvableValueElementMeta(element._meta);
+};
+export const isResolvableValueElementMeta = (meta) => {
+    return (!!meta.resolutionType &&
+        !!meta.resolvedType);
+};
+/**
+ * base class for leaf resolvable elements that are resolved into a value defined by the resolvedType property in the metadata
+ */
+export class ResolvableValueElement extends ResolvableElement {
+    constructor(data) {
+        super(data);
+        this.#setDefaultValue();
+    }
+    #setDefaultValue() {
+        const { defaultValue } = this._meta;
+        if (defaultValue) {
+            try {
+                this.value = ZincReader.readValue(defaultValue);
+            }
+            catch (e) {
+                console.error('Failed to parse element default value from: ', JSON.stringify(this._meta), e);
+            }
+        }
+    }
+}
 //# sourceMappingURL=ResolvableValueElement.js.map

package/dist_es/resolvableElements/elements/UiElement.d.ts

@@ -1,31 +1,31 @@
-import { Resolver } from '../Resolver';
-export interface UiElementData<Meta extends UiElementMeta = UiElementMeta> {
-    _meta?: Meta;
-}
-export interface UiElementMeta {
-    access?: string[];
-}
-export interface UiElementConstructorData<T extends UiElementData> {
-    resolver: Resolver;
-    onUpdate: (value: unknown | undefined) => void;
-    element: T;
-    name?: string;
-}
-/**
- * Base UiElement class
- */
-export declare abstract class UiElement<T extends UiElementData = UiElementData> {
-    #private;
-    constructor({ name, element, resolver, onUpdate, }: UiElementConstructorData<T>);
-    resolver: Resolver;
-    _meta?: UiElementMeta;
-    name?: string;
-    toJSON(): Record<string, unknown>;
-    inspect(): void;
-    isAccessAllowed(meta?: UiElementMeta): boolean;
-    protected _value?: unknown;
-    get value(): unknown | undefined;
-    set value(value: unknown | undefined);
-    onUpdate: (value: unknown | undefined) => void;
-    static joinFilters(...filter: (string | undefined)[]): string;
-}
+import { Resolver } from '../Resolver';
+export interface UiElementData<Meta extends UiElementMeta = UiElementMeta> {
+    _meta?: Meta;
+}
+export interface UiElementMeta {
+    access?: string[];
+}
+export interface UiElementConstructorData<T extends UiElementData> {
+    resolver: Resolver;
+    onUpdate: (value: unknown | undefined) => void;
+    element: T;
+    name?: string;
+}
+/**
+ * Base UiElement class
+ */
+export declare abstract class UiElement<T extends UiElementData = UiElementData> {
+    #private;
+    constructor({ name, element, resolver, onUpdate, }: UiElementConstructorData<T>);
+    resolver: Resolver;
+    _meta?: UiElementMeta;
+    name?: string;
+    toJSON(): Record<string, unknown>;
+    inspect(): void;
+    isAccessAllowed(meta?: UiElementMeta): boolean;
+    protected _value?: unknown;
+    get value(): unknown | undefined;
+    set value(value: unknown | undefined);
+    onUpdate: (value: unknown | undefined) => void;
+    static joinFilters(...filter: (string | undefined)[]): string;
+}

package/dist_es/resolvableElements/elements/UiElement.js

@@ -1,53 +1,53 @@
-/*
- * Copyright (c) 2022, J2 Innovations. All Rights Reserved
- */
-import { DEFAULT_USER_ROLE_TAG_NAME } from '../Resolver';
-/**
- * Base UiElement class
- */
-export class UiElement {
-    constructor({ name, element, resolver, onUpdate, }) {
-        this._meta = element._meta;
-        this.name = name;
-        this.resolver = resolver;
-        this.onUpdate = onUpdate;
-    }
-    resolver;
-    _meta;
-    name;
-    toJSON() {
-        return { _meta: this._meta };
-    }
-    inspect() {
-        console.log(this);
-    }
-    isAccessAllowed(meta) {
-        return UiElement.#isElementAccessible(meta, this.resolver.user, this.resolver.userRoleTagName);
-    }
-    _value;
-    get value() {
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-        this.onUpdate(value);
-    }
-    onUpdate;
-    static #isElementAccessible(meta, user, userRoleTagName = DEFAULT_USER_ROLE_TAG_NAME) {
-        if (!meta || !meta.access || UiElement.#isSuperuser(user)) {
-            return true;
-        }
-        const userRole = user?.get(userRoleTagName);
-        if (userRole && meta.access.includes(userRole.value)) {
-            return true;
-        }
-        return false;
-    }
-    static #isSuperuser(user) {
-        return user?.get('userRole')?.value === 'su';
-    }
-    static joinFilters(...filter) {
-        return filter.filter((filter) => filter).join(' and ');
-    }
-}
+/*
+ * Copyright (c) 2022, J2 Innovations. All Rights Reserved
+ */
+import { DEFAULT_USER_ROLE_TAG_NAME } from '../Resolver';
+/**
+ * Base UiElement class
+ */
+export class UiElement {
+    constructor({ name, element, resolver, onUpdate, }) {
+        this._meta = element._meta;
+        this.name = name;
+        this.resolver = resolver;
+        this.onUpdate = onUpdate;
+    }
+    resolver;
+    _meta;
+    name;
+    toJSON() {
+        return { _meta: this._meta };
+    }
+    inspect() {
+        console.log(this);
+    }
+    isAccessAllowed(meta) {
+        return UiElement.#isElementAccessible(meta, this.resolver.user, this.resolver.userRoleTagName);
+    }
+    _value;
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this.onUpdate(value);
+    }
+    onUpdate;
+    static #isElementAccessible(meta, user, userRoleTagName = DEFAULT_USER_ROLE_TAG_NAME) {
+        if (!meta || !meta.access || UiElement.#isSuperuser(user)) {
+            return true;
+        }
+        const userRole = user?.get(userRoleTagName);
+        if (userRole && meta.access.includes(userRole.value)) {
+            return true;
+        }
+        return false;
+    }
+    static #isSuperuser(user) {
+        return user?.get('userRole')?.value === 'su';
+    }
+    static joinFilters(...filter) {
+        return filter.filter((filter) => filter).join(' and ');
+    }
+}
 //# sourceMappingURL=UiElement.js.map

package/dist_es/resolvableElements/elements/expr/ResolvableExprElement.d.ts

@@ -1,26 +1,26 @@
-import { HDict } from 'haystack-core';
-import { ResolvableValueElement } from '../ResolvableValueElement';
-import { UiElementConstructorData, UiElementData } from '../UiElement';
-import { ResolvableExprElementMeta } from './ResolvableExprElementMeta';
-/**
- * Resolves to the result of an expression.
- */
-export declare class ResolvableExprElement<T extends UiElementData> extends ResolvableValueElement<T> {
-    #private;
-    constructor(data: UiElementConstructorData<T>);
-    refreshes: number;
-    protected getMeta: () => ResolvableExprElementMeta;
-    protected doInitialize: (parameters: HDict) => Promise<void>;
-    /**
-     * Checks whether the declared resolvedType of this element is a collection.
-     * @returns true if the resolvedType is a collection.
-     */
-    isExpectedResultACollection: () => boolean;
-    /**
-     * Checks whether the declared resolvedType of this element is a single value.
-     * @returns true if the resolvedType is a value.
-     */
-    isExpectedResultVal: () => boolean;
-    protected doClose: () => Promise<void>;
-    getParameterList: () => string[];
-}
+import { HDict } from 'haystack-core';
+import { ResolvableValueElement } from '../ResolvableValueElement';
+import { UiElementConstructorData, UiElementData } from '../UiElement';
+import { ResolvableExprElementMeta } from './ResolvableExprElementMeta';
+/**
+ * Resolves to the result of an expression.
+ */
+export declare class ResolvableExprElement<T extends UiElementData> extends ResolvableValueElement<T> {
+    #private;
+    constructor(data: UiElementConstructorData<T>);
+    refreshes: number;
+    protected getMeta: () => ResolvableExprElementMeta;
+    protected doInitialize: (parameters: HDict) => Promise<void>;
+    /**
+     * Checks whether the declared resolvedType of this element is a collection.
+     * @returns true if the resolvedType is a collection.
+     */
+    isExpectedResultACollection: () => boolean;
+    /**
+     * Checks whether the declared resolvedType of this element is a single value.
+     * @returns true if the resolvedType is a value.
+     */
+    isExpectedResultVal: () => boolean;
+    protected doClose: () => Promise<void>;
+    getParameterList: () => string[];
+}