Create privileges package

packages/privileges/.eslintignore

@@ -0,0 +1,2 @@
+dist
+*.config.js

packages/privileges/.eslintrc

@@ -0,0 +1,3 @@
+{
+    "extends": "@reactive-tools/eslint-config"
+}

packages/privileges/aqu.config.json

@@ -0,0 +1,14 @@
+{
+    "buildOptions": {
+        "target": ["es2019", "chrome58", "firefox57", "safari11", "edge16", "node12"]
+    },
+    "dtsBundleGeneratorOptions": {
+        "output": {
+            "inlineDeclareExternals": true
+        },
+        "libraries": {
+            "importedLibraries": ["react", "@reactive-forms/core", "pxth"],
+            "allowedTypesLibraries": []
+        }
+    }
+}

packages/privileges/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@reactive-forms/privileges",
+    "version": "0.6.3",
+    "description": "Package for field privileges",
+    "author": "ReactiveForms team",
+    "homepage": "https://github.com/ArtiomTr/reactive-forms#readme",
+    "license": "MIT",
+    "main": "dist/index.js",
+    "source": "src/index.ts",
+    "types": "dist/privileges.d.ts",
+    "scripts": {
+        "build": "aqu build",
+        "test": "aqu test --passWithNoTests",
+        "test:watch": "aqu test --watch",
+        "test:coverage": "aqu test --coverage --json --silent --ci --outputFile=\"report.json\"",
+        "test:log-coverage": "aqu test --coverage --silent --ci --coverageReporters=text",
+        "lint": "eslint .",
+        "lint:fix": "npm run lint --fix",
+        "prepublish": "reactive-publisher"
+    },
+    "devDependencies": {
+        "@reactive-forms/core": "*",
+        "@reactive-tools/eslint-config": "*",
+        "@reactive-tools/publisher": "*",
+        "@testing-library/react-hooks": "^7.0.2",
+        "aqu": "^0.1.1",
+        "react": "^17.0.2",
+        "typescript": "^4.5.4"
+    },
+    "dependencies": {
+        "pxth": "^0.5.0",
+        "tiny-invariant": "^1.2.0"
+    },
+    "peerDependencies": {
+        "@reactive-forms/core": "^0.5.0",
+        "react": ">=16"
+    }
+}

packages/privileges/src/getFieldPrivileges.ts

@@ -0,0 +1,45 @@
+import { createPxth, deepGet, getPxthSegments, Pxth } from 'pxth';
+
+import { FieldPrivileges } from './typings/FieldPrivileges';
+import { FormPrivileges } from './typings/FormPrivileges';
+import { defaultPrivileges } from './useFieldPrivileges';
+
+const getParentPath = <V>(path: Pxth<V>) => {
+    const pathSegments = getPxthSegments(path);
+
+    if (pathSegments.length > 0) {
+        pathSegments.pop();
+    }
+
+    return createPxth(pathSegments);
+};
+
+const mergePrivileges = (acc: FieldPrivileges, privileges: FieldPrivileges) => {
+    acc.disabled ??= privileges.disabled;
+    acc.isEditable ??= privileges.isEditable;
+    acc.visible ??= privileges.visible;
+};
+
+export const getFieldPrivileges = <V, T extends object>(
+    path: Pxth<V>,
+    privileges: FormPrivileges<T>
+): FieldPrivileges => {
+    const mergedPrivileges: FieldPrivileges = {};
+
+    let currentPath = path as Pxth<unknown>;
+
+    while (getPxthSegments(currentPath).length > 0) {
+        const currentPrivileges: FieldPrivileges | undefined = deepGet(privileges.fields, path);
+
+        if (currentPrivileges) {
+            mergePrivileges(mergedPrivileges, currentPrivileges);
+        }
+
+        currentPath = getParentPath(path);
+    }
+
+    mergePrivileges(mergedPrivileges, privileges.fields);
+    mergePrivileges(mergedPrivileges, defaultPrivileges);
+
+    return mergedPrivileges;
+};

packages/privileges/src/index.ts

@@ -0,0 +1,21 @@
+import { FormPrivileges } from './typings/FormPrivileges';
+
+export * from './plugin';
+export * from './getFieldPrivileges';
+export * from './useFieldPrivileges';
+
+// typings
+export * from './typings/FieldPrivileges';
+export * from './typings/ObjectPrivileges';
+export * from './typings/Privileges';
+export * from './typings/FormPrivileges';
+
+declare module '@reactive-forms/core' {
+    interface FormShared<Values extends object> {
+        privileges?: FormPrivileges<Values>;
+    }
+
+    interface ExtendableFormConfig<Values extends object> {
+        privileges?: FormPrivileges<Values>;
+    }
+}

packages/privileges/src/plugin.ts

@@ -0,0 +1,10 @@
+import { FormConfig, FormShared, Plugin } from '@reactive-forms/core';
+
+export const privilegesPlugin: Plugin = {
+    token: Symbol.for('privileges'),
+    useBagDecorator: <T extends object>(shared: FormShared<T>, config: FormConfig<T>) => ({
+        ...shared,
+        privileges: config.privileges
+    }),
+    useConfigDecorator: (config) => config
+};

packages/privileges/src/typings/FieldPrivileges.ts

@@ -0,0 +1,5 @@
+export type FieldPrivileges = {
+    visible?: boolean;
+    disabled?: boolean;
+    isEditable?: boolean;
+};

packages/privileges/src/typings/FormPrivileges.ts

@@ -0,0 +1,5 @@
+import { Privileges } from './Privileges';
+
+export type FormPrivileges<T extends object> = {
+    fields: Privileges<T>;
+};

packages/privileges/src/typings/ObjectPrivileges.ts

@@ -0,0 +1,5 @@
+import { Privileges } from './Privileges';
+
+export type ObjectPrivileges<T> = {
+    [P in keyof T]?: Privileges<T[P] extends Array<unknown> ? T[P][0] : T[P]>;
+};

packages/privileges/src/typings/Privileges.ts

@@ -0,0 +1,6 @@
+import { FieldPrivileges } from './FieldPrivileges';
+import { ObjectPrivileges } from './ObjectPrivileges';
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+
+export type Privileges<T> = T extends Primitive ? FieldPrivileges : FieldPrivileges & ObjectPrivileges<T>;

packages/privileges/src/useFieldPrivileges.ts

@@ -0,0 +1,33 @@
+import { useContext } from 'react';
+import { FormProxyContext, useFormContext, usePluginAssertion } from '@reactive-forms/core';
+import { Pxth } from 'pxth';
+
+import { FieldPrivileges } from './typings/FieldPrivileges';
+import { getFieldPrivileges } from './getFieldPrivileges';
+import { privilegesPlugin } from './plugin';
+
+export const defaultPrivileges: FieldPrivileges = {
+    disabled: false,
+    isEditable: true,
+    visible: true
+};
+
+export const useFieldPrivileges = <V>(path: Pxth<V>): FieldPrivileges => {
+    usePluginAssertion(
+        privilegesPlugin,
+        'Privileges plugin is required to use privileges. Please add privilegesPlugin to <FormPlugins>.'
+    );
+
+    const context = useFormContext();
+    const proxyContext = useContext(FormProxyContext);
+
+    if (!context.privileges) {
+        return defaultPrivileges;
+    }
+
+    if (proxyContext) {
+        path = proxyContext.getNormalPath(path);
+    }
+
+    return getFieldPrivileges(path, context.privileges);
+};

packages/privileges/tests/getFieldPrivileges.test.ts

@@ -0,0 +1,53 @@
+import { createPxth } from 'pxth';
+
+import { getFieldPrivileges } from '../src/getFieldPrivileges';
+import { defaultPrivileges } from '../src/useFieldPrivileges';
+
+describe('getFieldPrivileges', () => {
+    it('should merge privileges from upper nodes', () => {
+        const privileges = getFieldPrivileges<number, { some: { nested: { path: number } } }>(
+            createPxth(['some', 'nested', 'path']),
+            {
+                fields: {
+                    disabled: true,
+                    isEditable: false,
+                    some: {
+                        isEditable: true,
+                        nested: {
+                            disabled: false,
+                            path: {
+                                visible: true
+                            }
+                        }
+                    }
+                }
+            }
+        );
+
+        expect(privileges).toStrictEqual({
+            isEditable: true,
+            disabled: false,
+            visible: true
+        });
+    });
+
+    it('should combine privileges with default privileges', () => {
+        const privileges = getFieldPrivileges<number, { some: { nested: { path: number } } }>(
+            createPxth(['some', 'nested', 'path']),
+            {
+                fields: {
+                    some: {
+                        nested: {
+                            isEditable: false,
+                            path: {
+                                visible: true
+                            }
+                        }
+                    }
+                }
+            }
+        );
+
+        expect(privileges.disabled).toBe(defaultPrivileges.disabled);
+    });
+});

packages/privileges/tests/index.d.ts

@@ -0,0 +1,11 @@
+import { FormPrivileges } from '../src/typings/FormPrivileges';
+
+declare module '@reactive-forms/core' {
+    interface FormShared<Values extends object> {
+        privileges?: FormPrivileges<Values>;
+    }
+
+    interface ExtendableFormConfig<Values extends object> {
+        privileges?: FormPrivileges<Values>;
+    }
+}