@evergis/react 4.0.166 → 4.0.168

package/dist/taskParameters/index.js

@@ -0,0 +1,329 @@
+'use strict';
+
+const compareByOrder = (left, right) => {
+    const leftOrder = left?.["x-order"];
+    const rightOrder = right?.["x-order"];
+    if (leftOrder !== undefined && rightOrder !== undefined) {
+        return leftOrder - rightOrder;
+    }
+    if (leftOrder !== undefined) {
+        return -1;
+    }
+    if (rightOrder !== undefined) {
+        return 1;
+    }
+    return 0;
+};
+const orderPropertyKeys = (schema) => {
+    const keys = Object.keys(schema.properties ?? {});
+    const required = schema.required ?? [];
+    const properties = schema.properties ?? {};
+    const hasExplicitOrder = keys.some(key => properties[key]?.["x-order"] !== undefined);
+    if (hasExplicitOrder) {
+        return [...keys].sort((leftKey, rightKey) => compareByOrder(properties[leftKey], properties[rightKey]));
+    }
+    const requiredSet = new Set(required);
+    const requiredOrdered = required.filter(key => keys.includes(key));
+    const rest = keys.filter(key => !requiredSet.has(key));
+    return [...requiredOrdered, ...rest];
+};
+
+const getPrimaryType = (schema) => {
+    if (!schema?.type) {
+        return undefined;
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.find(typeName => typeName !== "null") ?? schema.type[0];
+    }
+    return schema.type;
+};
+
+const FORM_DEFAULT_OPTIONS = {
+    stringDefault: undefined,
+    objectDepth: "recursive",
+    propertyKeys: "default",
+    emptyObject: "undefined",
+    ignoreSchemaDefault: false,
+};
+const ARRAY_ITEM_OBJECT_OPTIONS = {
+    stringDefault: "",
+    objectDepth: "shallow",
+    propertyKeys: "ordered",
+    emptyObject: "empty",
+    ignoreSchemaDefault: true,
+};
+const getPropertyKeys = (resolved, propertyKeys) => {
+    if (propertyKeys === "ordered") {
+        return orderPropertyKeys(resolved);
+    }
+    return Object.keys(resolved.properties ?? {});
+};
+const buildShallowChildDefault = (resolver, childSchema, options) => {
+    const childResolved = resolver.resolve(childSchema) ?? childSchema;
+    if (childResolved.default !== undefined) {
+        return childResolved.default;
+    }
+    const primaryType = getPrimaryType(childResolved);
+    if (primaryType === "boolean") {
+        return false;
+    }
+    if (primaryType === "string" && options.stringDefault !== undefined) {
+        return options.stringDefault;
+    }
+    return undefined;
+};
+const buildDefault = (resolver, schema, options, ignoreSchemaDefault) => {
+    const resolved = resolver.resolve(schema);
+    if (!resolved) {
+        return undefined;
+    }
+    if (!ignoreSchemaDefault && resolved.default !== undefined) {
+        return resolved.default;
+    }
+    const primaryType = getPrimaryType(resolved);
+    if (primaryType === "object" && resolved.properties) {
+        const result = {};
+        const keys = getPropertyKeys(resolved, options.propertyKeys);
+        for (const key of keys) {
+            const childSchema = resolved.properties[key];
+            const childDefault = options.objectDepth === "shallow"
+                ? buildShallowChildDefault(resolver, childSchema, options)
+                : buildDefault(resolver, childSchema, options, false);
+            if (childDefault !== undefined) {
+                result[key] = childDefault;
+            }
+        }
+        if (Object.keys(result).length === 0) {
+            return options.emptyObject === "empty" ? {} : undefined;
+        }
+        return result;
+    }
+    if (primaryType === "array" && options.objectDepth === "recursive") {
+        return [];
+    }
+    if (primaryType === "boolean") {
+        return false;
+    }
+    if (primaryType === "integer" || primaryType === "number") {
+        return undefined;
+    }
+    if (primaryType === "string" && options.stringDefault !== undefined) {
+        return options.stringDefault;
+    }
+    return undefined;
+};
+const buildDefaultForSchema = (resolver, schema, options) => {
+    const mergedOptions = {
+        ...FORM_DEFAULT_OPTIONS,
+        ...options,
+    };
+    return buildDefault(resolver, schema, mergedOptions, mergedOptions.ignoreSchemaDefault);
+};
+
+const getHiddenDefaultValue = (resolver, propertySchema) => {
+    const resolved = resolver.resolve(propertySchema) ?? propertySchema;
+    if (resolved.default !== undefined) {
+        return resolved.default;
+    }
+    return undefined;
+};
+const mergeHiddenFieldsAtLevel = (resolver, schema, data) => {
+    const resolved = resolver.resolve(schema) ?? schema;
+    const properties = resolved.properties ?? {};
+    if (Object.keys(properties).length === 0) {
+        return data;
+    }
+    let result = { ...data };
+    for (const [propertyKey, propertySchema] of Object.entries(properties)) {
+        const propertyResolved = resolver.resolve(propertySchema) ?? propertySchema;
+        if (propertyResolved["x-hide"]) {
+            if (result[propertyKey] !== undefined) {
+                continue;
+            }
+            const hiddenDefault = getHiddenDefaultValue(resolver, propertySchema);
+            if (hiddenDefault !== undefined) {
+                result = { ...result, [propertyKey]: hiddenDefault };
+            }
+            continue;
+        }
+        const primaryType = getPrimaryType(propertyResolved);
+        if (primaryType === "object" && propertyResolved.properties) {
+            const nestedData = result[propertyKey] !== null && typeof result[propertyKey] === "object" && !Array.isArray(result[propertyKey])
+                ? result[propertyKey]
+                : {};
+            const mergedNested = mergeHiddenFieldsAtLevel(resolver, propertySchema, nestedData);
+            if (mergedNested !== nestedData) {
+                result = { ...result, [propertyKey]: mergedNested };
+            }
+        }
+    }
+    return result;
+};
+const mergeHiddenFieldDefaults = (resolver, formData) => {
+    return mergeHiddenFieldsAtLevel(resolver, resolver.rootSchema, formData);
+};
+
+const EVERGIS_TYPE_ATTRIBUTE = "Attribute";
+const scopeToKeys = (scope) => {
+    if (!scope.startsWith("#/")) {
+        return [];
+    }
+    return scope
+        .slice(2)
+        .split("/")
+        .filter(segment => segment !== "properties");
+};
+const isAttributeStringSchema = (schema) => getPrimaryType(schema) === "string" && schema["x-evergis-type"] === EVERGIS_TYPE_ATTRIBUTE;
+class SchemaResolver {
+    root;
+    constructor(rootSchema) {
+        this.root = rootSchema;
+    }
+    get rootSchema() {
+        return this.root;
+    }
+    resolve(schema) {
+        if (!schema) {
+            return undefined;
+        }
+        if (schema.$ref) {
+            return this.resolve(this.resolveRef(schema.$ref));
+        }
+        if (schema.allOf?.length) {
+            return this.mergeAllOf(schema.allOf);
+        }
+        if (schema.oneOf?.length) {
+            return this.resolve(schema.oneOf[0]);
+        }
+        if (schema.anyOf?.length) {
+            return this.resolve(schema.anyOf[0]);
+        }
+        return schema;
+    }
+    oneOfBranches(schema) {
+        if (!schema) {
+            return [];
+        }
+        if (schema.$ref) {
+            return this.oneOfBranches(this.resolveRef(schema.$ref));
+        }
+        if (schema.allOf?.length) {
+            return [this.mergeAllOf(schema.allOf)];
+        }
+        if (schema.oneOf?.length) {
+            return schema.oneOf.map(branch => this.resolve(branch)).filter(Boolean);
+        }
+        if (schema.anyOf?.length) {
+            return schema.anyOf.map(branch => this.resolve(branch)).filter(Boolean);
+        }
+        return [schema];
+    }
+    schemaAtScope(scope) {
+        const keys = scopeToKeys(scope);
+        let current = this.resolve(this.root);
+        for (const key of keys) {
+            if (!current) {
+                return undefined;
+            }
+            const resolved = this.resolve(current);
+            const properties = resolved?.properties;
+            if (!properties?.[key]) {
+                return undefined;
+            }
+            current = properties[key];
+        }
+        return this.resolve(current);
+    }
+    isScopeRequired(scope) {
+        const keys = scopeToKeys(scope);
+        if (keys.length === 0) {
+            return false;
+        }
+        let current = this.resolve(this.root);
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            const resolved = this.resolve(current);
+            const required = resolved?.required ?? [];
+            if (index === keys.length - 1) {
+                return required.includes(key);
+            }
+            current = resolved?.properties?.[key];
+        }
+        return false;
+    }
+    arrayItemSchema(itemsSchema) {
+        if (!itemsSchema) {
+            return undefined;
+        }
+        const branches = this.oneOfBranches(itemsSchema);
+        if (branches.length === 1) {
+            return this.resolve(branches[0]);
+        }
+        return this.resolve(itemsSchema);
+    }
+    arrayItemKind(arraySchema) {
+        const resolvedArray = this.resolve(arraySchema) ?? arraySchema;
+        const itemSchema = this.arrayItemSchema(resolvedArray.items);
+        if (!itemSchema) {
+            return null;
+        }
+        const itemResolved = this.resolve(itemSchema) ?? itemSchema;
+        const branches = this.oneOfBranches(resolvedArray.items ?? itemSchema);
+        if (branches.length === 1 && isAttributeStringSchema(branches[0])) {
+            return { kind: "attribute", itemSchema: branches[0] };
+        }
+        if (isAttributeStringSchema(itemResolved)) {
+            return { kind: "attribute", itemSchema: itemResolved };
+        }
+        const primaryType = getPrimaryType(itemResolved);
+        if (primaryType === "string") {
+            return { kind: "string", itemSchema: itemResolved };
+        }
+        if (primaryType === "object" && itemResolved.properties) {
+            return { kind: "composite", itemSchema: itemResolved };
+        }
+        return null;
+    }
+    resolveRef(ref) {
+        if (!ref.startsWith("#/")) {
+            return undefined;
+        }
+        const segments = ref.slice(2).split("/");
+        let current = this.root;
+        for (const segment of segments) {
+            if (!current) {
+                return undefined;
+            }
+            current = current[segment];
+        }
+        return current;
+    }
+    mergeAllOf(schemas) {
+        const merged = { type: "object", properties: {} };
+        for (const part of schemas) {
+            const resolved = this.resolve(part);
+            if (resolved?.properties) {
+                merged.properties = { ...merged.properties, ...resolved.properties };
+            }
+            if (resolved?.type && !merged.type) {
+                merged.type = resolved.type;
+            }
+            if (resolved?.description && !merged.description) {
+                merged.description = resolved.description;
+            }
+            if (resolved?.["x-evergis-type"] && !merged["x-evergis-type"]) {
+                merged["x-evergis-type"] = resolved["x-evergis-type"];
+            }
+        }
+        return merged;
+    }
+}
+
+exports.ARRAY_ITEM_OBJECT_OPTIONS = ARRAY_ITEM_OBJECT_OPTIONS;
+exports.FORM_DEFAULT_OPTIONS = FORM_DEFAULT_OPTIONS;
+exports.SchemaResolver = SchemaResolver;
+exports.buildDefaultForSchema = buildDefaultForSchema;
+exports.getPrimaryType = getPrimaryType;
+exports.mergeHiddenFieldDefaults = mergeHiddenFieldDefaults;
+exports.orderPropertyKeys = orderPropertyKeys;
+//# sourceMappingURL=index.js.map

package/dist/taskParameters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/taskParameters/package.json

@@ -0,0 +1 @@
+{"type":"commonjs","main":"index.js","types":"../taskParameters.d.ts"}

package/dist/taskParameters.d.ts

@@ -0,0 +1,2 @@
+/** Работа со схемой и значениями по умолчанию без загрузки React-компонентов и браузерных зависимостей. */
+export * from './utils/taskParameters';

package/dist/utils/index.d.ts

@@ -9,3 +9,4 @@ export * from './isNumeric';
 export * from './isObject';
 export * from './metersPerPixel';
 export * from './roundTotalSum';
+export * from './taskParameters';

package/dist/utils/isObject.d.ts

@@ -1 +1 @@
-export declare function isObject<T>(value: T | object): value is object;
+export declare function isObject<T>(value: T | object): value is T & object & Record<string, unknown>;

package/dist/utils/taskParameters/SchemaResolver.d.ts

@@ -0,0 +1,14 @@
+import { ArrayItemDetection, JsonSchemaNode } from './types';
+export declare class SchemaResolver {
+    private readonly root;
+    constructor(rootSchema: JsonSchemaNode);
+    get rootSchema(): JsonSchemaNode;
+    resolve(schema?: JsonSchemaNode): JsonSchemaNode | undefined;
+    oneOfBranches(schema?: JsonSchemaNode): JsonSchemaNode[];
+    schemaAtScope(scope: string): JsonSchemaNode | undefined;
+    isScopeRequired(scope: string): boolean;
+    arrayItemSchema(itemsSchema?: JsonSchemaNode): JsonSchemaNode | undefined;
+    arrayItemKind(arraySchema: JsonSchemaNode): ArrayItemDetection | null;
+    private resolveRef;
+    private mergeAllOf;
+}

package/dist/utils/taskParameters/buildDefaultForSchema.d.ts

@@ -0,0 +1,23 @@
+import { SchemaResolver } from './SchemaResolver';
+import { JsonSchemaNode } from './types';
+type ObjectDepth = "recursive" | "shallow";
+type PropertyKeysOrder = "default" | "ordered";
+type EmptyObjectResult = "undefined" | "empty";
+export type BuildDefaultForSchemaOptions = {
+    stringDefault?: string;
+    objectDepth?: ObjectDepth;
+    propertyKeys?: PropertyKeysOrder;
+    emptyObject?: EmptyObjectResult;
+    ignoreSchemaDefault?: boolean;
+};
+type ResolvedBuildDefaultOptions = {
+    stringDefault: string | undefined;
+    objectDepth: ObjectDepth;
+    propertyKeys: PropertyKeysOrder;
+    emptyObject: EmptyObjectResult;
+    ignoreSchemaDefault: boolean;
+};
+export declare const FORM_DEFAULT_OPTIONS: ResolvedBuildDefaultOptions;
+export declare const ARRAY_ITEM_OBJECT_OPTIONS: ResolvedBuildDefaultOptions;
+export declare const buildDefaultForSchema: (resolver: SchemaResolver, schema?: JsonSchemaNode, options?: BuildDefaultForSchemaOptions) => unknown;
+export {};

package/dist/utils/taskParameters/getPrimaryType.d.ts

@@ -0,0 +1,2 @@
+import { JsonSchemaNode } from './types';
+export declare const getPrimaryType: (schema?: JsonSchemaNode) => string | undefined;

package/dist/utils/taskParameters/index.d.ts

@@ -0,0 +1,6 @@
+export * from './orderPropertyKeys';
+export * from './buildDefaultForSchema';
+export * from './getPrimaryType';
+export * from './mergeHiddenFieldDefaults';
+export * from './SchemaResolver';
+export * from './types';

package/dist/utils/taskParameters/mergeHiddenFieldDefaults.d.ts

@@ -0,0 +1,2 @@
+import { SchemaResolver } from './SchemaResolver';
+export declare const mergeHiddenFieldDefaults: (resolver: SchemaResolver, formData: Record<string, unknown>) => Record<string, unknown>;

package/dist/utils/taskParameters/orderPropertyKeys.d.ts

@@ -0,0 +1,2 @@
+import { JsonSchemaNode } from './types';
+export declare const orderPropertyKeys: (schema: JsonSchemaNode) => string[];

package/dist/utils/taskParameters/types.d.ts

@@ -0,0 +1,36 @@
+export interface JsonSchemaNode {
+    $schema?: string;
+    title?: string;
+    type?: string | string[];
+    description?: string;
+    properties?: Record<string, JsonSchemaNode>;
+    items?: JsonSchemaNode;
+    required?: string[];
+    enum?: unknown[];
+    default?: unknown;
+    format?: string;
+    oneOf?: JsonSchemaNode[];
+    allOf?: JsonSchemaNode[];
+    anyOf?: JsonSchemaNode[];
+    $ref?: string;
+    definitions?: Record<string, JsonSchemaNode>;
+    additionalProperties?: boolean | JsonSchemaNode;
+    "x-evergis-type"?: string;
+    "x-source"?: string;
+    "x-order"?: number;
+    "x-abstract"?: boolean;
+    "x-hide"?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    nullable?: boolean;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    methodName?: string;
+    fileName?: string;
+}
+export type ArrayItemKind = "string" | "attribute" | "composite";
+export interface ArrayItemDetection {
+    kind: ArrayItemKind;
+    itemSchema: JsonSchemaNode;
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.166",
+  "version": "4.0.168",
   "name": "@evergis/react",
   "author": "Everpoint",
   "license": "MIT",
@@ -96,5 +96,5 @@
     "uuid": "^13.0.0",
     "wkt": "^0.1.1"
   },
-  "gitHead": "63e1e15286961256c97f8541c5865bcbd398d601"
+  "gitHead": "2c3ed788cb461fa2ec163d695ead272005d9309f"
 }

package/dist/components/Dashboard/containers/TaskContainer/useTaskNotifications.d.ts

@@ -1,12 +0,0 @@
-import { RemoteTaskStatus } from '@evergis/api';
-interface UseTaskNotificationsParams {
-    enabled: boolean;
-    suppressed: boolean;
-    status: RemoteTaskStatus;
-    lastMessage: string | null;
-    openLog: () => void;
-}
-export declare const useTaskNotifications: ({ enabled, suppressed, status, lastMessage, openLog, }: UseTaskNotificationsParams) => {
-    setNotificationDismissed: import('react').Dispatch<import('react').SetStateAction<boolean>>;
-};
-export {};