@siliconst/metaui 1.4.51 → 2.0.0

package/src/nz/co/siliconst/ui5/metaui/utils/Logger.ts

@@ -1,75 +1,93 @@
-/**
- * @file Logger.ts
- * @description Centralized logging utility for MetaUI.
- * Wraps sap/base/Log and provides a global toggle for debug mode.
- */
-
-export class Logger {
-    private static debugMode: boolean = false;
-    private static logInstance: any = null;
-
-    /**
-     * Toggles the global debug mode for MetaUI.
-     * @param enabled Set to true to enable logging.
-     */
-    public static setDebugMode(enabled: boolean): void {
-        this.debugMode = enabled;
-        if (enabled && !this.logInstance) {
-            sap.ui.require(["sap/base/Log"], (Log: Record<string, Function>) => {
-                this.logInstance = Log;
-            });
-        }
-    }
-
-    /**
-     * Checks if debug mode is currently active.
-     */
-    public static isDebugMode(): boolean {
-        return this.debugMode;
-    }
-
-    public static debug(message: string, details?: string, component?: string): void {
-        if (!this.debugMode) return;
-        if (this.logInstance) {
-            this.logInstance.debug(message, details, component || "MetaUI");
-        } else {
-            console.debug(`[MetaUI] ${message}`, details || "");
-        }
-    }
-
-    public static info(message: string, details?: string, component?: string): void {
-        if (!this.debugMode) return;
-        if (this.logInstance) {
-            this.logInstance.info(message, details, component || "MetaUI");
-        } else {
-            console.info(`[MetaUI] ${message}`, details || "");
-        }
-    }
-
-    public static warn(message: string, details?: string, component?: string): void {
-        if (!this.debugMode) return;
-        if (this.logInstance) {
-            this.logInstance.warning(message, details, component || "MetaUI");
-        } else {
-            console.warn(`[MetaUI] ${message}`, details || "");
-        }
-    }
-
-    public static error(message: string, details?: string, component?: string): void {
-        if (this.logInstance) {
-            this.logInstance.error(message, details, component || "MetaUI");
-        } else {
-            console.error(`[MetaUI Error] ${message}`, details || "");
-        }
-    }
-
-    /**
-     * Pops up a MessageBox UI alert if debug mode is active.
-     */
-    public static showErrorPopup(message: string, title?: string): void {
-        if (!this.debugMode) return;
-        sap.ui.require(["sap/m/MessageBox"], (MessageBox: Record<string, Function>) => {
-            (MessageBox as Record<string, Function>).error(message, { title: title || "MetaUI Error" });
-        });
-    }
-}
+/**
+ * @file Logger.ts
+ * @description Centralized logging utility for MetaUI.
+ * Wraps sap/base/Log and provides a global toggle for debug mode.
+ */
+
+import Log from "sap/base/Log";
+
+const DEFAULT_COMPONENT = "MetaUI";
+
+/**
+ * Centralized logging facade for the MetaUI library.
+ *
+ * - `debug` and `info` are gated behind {@link Logger.setDebugMode} to keep production consoles clean.
+ * - `warn` and `error` are **always** emitted so schema misconfigurations, unregistered widgets and
+ *   runtime failures never fail silently.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.utils
+ * @public
+ */
+export class Logger {
+    private static debugMode: boolean = false;
+
+    /**
+     * Toggles the global debug mode for MetaUI.
+     * @param enabled Set to true to enable debug/info logging and diagnostic error popups.
+     */
+    public static setDebugMode(enabled: boolean): void {
+        this.debugMode = enabled;
+    }
+
+    /**
+     * Checks if debug mode is currently active.
+     * @returns {boolean} True when debug logging is enabled.
+     */
+    public static isDebugMode(): boolean {
+        return this.debugMode;
+    }
+
+    /**
+     * Emits a debug entry when debug mode is active.
+     * @param message Primary log message.
+     * @param details Optional supplementary details.
+     * @param component Optional UI5 log component name.
+     */
+    public static debug(message: string, details?: string, component?: string): void {
+        if (!this.debugMode) return;
+        Log.debug(message, details, component || DEFAULT_COMPONENT);
+    }
+
+    /**
+     * Emits an informational entry when debug mode is active.
+     * @param message Primary log message.
+     * @param details Optional supplementary details.
+     * @param component Optional UI5 log component name.
+     */
+    public static info(message: string, details?: string, component?: string): void {
+        if (!this.debugMode) return;
+        Log.info(message, details, component || DEFAULT_COMPONENT);
+    }
+
+    /**
+     * Emits a warning entry unconditionally (warnings must never be suppressed).
+     * @param message Primary warning message.
+     * @param details Optional supplementary details.
+     * @param component Optional UI5 log component name.
+     */
+    public static warn(message: string, details?: string, component?: string): void {
+        Log.warning(message, details, component || DEFAULT_COMPONENT);
+    }
+
+    /**
+     * Emits an error entry unconditionally.
+     * @param message Primary error message.
+     * @param details Optional supplementary details.
+     * @param component Optional UI5 log component name.
+     */
+    public static error(message: string, details?: string, component?: string): void {
+        Log.error(message, details, component || DEFAULT_COMPONENT);
+    }
+
+    /**
+     * Pops up a MessageBox UI alert if debug mode is active.
+     * @param message Error message to display.
+     * @param title Optional dialog title.
+     */
+    public static showErrorPopup(message: string, title?: string): void {
+        if (!this.debugMode) return;
+        sap.ui.require(["sap/m/MessageBox"], (MessageBox: { error: (msg: string, opts?: { title?: string }) => void }) => {
+            MessageBox.error(message, { title: title || "MetaUI Error" });
+        });
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/utils/PolicyConditionUtil.ts

@@ -0,0 +1,45 @@
+/**
+ * @file PolicyConditionUtil.ts
+ * @description Shared coercion and pointer-or-literal threshold resolution helpers for PolicyEngine condition plugins.
+ */
+
+/**
+ * Shared utility methods for policy condition plugins (`NumericGreaterThan`, `NumericLessThan`, `DateLessThan`).
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.utils
+ * @internal
+ */
+export class PolicyConditionUtil {
+    /**
+     * Safely coerces an arbitrary value into a finite number, returning `NaN` for empty or unparseable values.
+     *
+     * @param value The candidate value to coerce.
+     * @returns {number} The numeric value, or `NaN` if empty/invalid.
+     */
+    public static coerceToNumber(value: unknown): number {
+        if (value === undefined || value === null || value === "") {
+            return NaN;
+        }
+        return Number(value);
+    }
+
+    /**
+     * Resolves a condition threshold that may be either a literal value or a JSON pointer (`/...` or `$row/...`).
+     *
+     * @param rawThreshold The raw threshold value or pointer string.
+     * @param data The live JSON model payload.
+     * @param resolvePointer The pointer resolution callback injected by `PolicyEngine`.
+     * @returns {unknown} The resolved comparison target value.
+     */
+    public static resolveThreshold(
+        rawThreshold: unknown,
+        data: unknown,
+        resolvePointer: (d: unknown, p: string) => unknown
+    ): unknown {
+        if (typeof rawThreshold === "string" && (rawThreshold.startsWith("/") || rawThreshold.includes("$row"))) {
+            return resolvePointer(data, rawThreshold);
+        }
+        return rawThreshold;
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/utils/PolymorphicUtil.ts

@@ -0,0 +1,301 @@
+/**
+ * @file PolymorphicUtil.ts
+ * @description Pure specification-driven utilities for resolving JSON Schema and OpenAPI 2.0/3.0
+ * polymorphic variants (`oneOf`, `anyOf`, `discriminator`, and `$ref` branches) and detecting
+ * the active variant from a runtime data object.
+ */
+
+import { IPropertyMetadata, ISchema } from "../interfaces/ISchema";
+import { WIDGET_TYPE } from "../constants/MetaUIConstants";
+import { OpenApiRefResolver } from "../openapi/OpenApiRefResolver";
+import { deepClone, isRecord, readString } from "./TypeGuards";
+import JSONModel from "sap/ui/model/json/JSONModel";
+
+/**
+ * Resolved descriptor for a single `oneOf` or `anyOf` polymorphic branch.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.utils
+ * @internal
+ */
+export interface IPolymorphicVariant {
+    /** Unique variant key (discriminator value, `$ref` schema name, or branch key). */
+    readonly key: string;
+    /** Human-readable title displayed in the variant selector dropdown. */
+    readonly title: string;
+    /** Merged map of child property metadata for this variant branch. */
+    readonly properties: Record<string, IPropertyMetadata>;
+}
+
+/**
+ * Stateless helper methods for `PolymorphicPlugin`.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.utils
+ * @internal
+ */
+export class PolymorphicUtil {
+    /**
+     * Extracts normalized variant descriptors from `metadata.oneOf` or `metadata.anyOf`,
+     * resolving `$ref` pointers against `definitions` and propagating branch-level `required` arrays.
+     * Falls back to synthesizing a variant from `metadata.properties` when `oneOf`/`anyOf` are absent.
+     *
+     * @param metadata The polymorphic property metadata.
+     * @param definitions Optional global `$ref` definitions dictionary.
+     * @returns {IPolymorphicVariant[]} Array of resolved variants.
+     */
+    public static extractVariants(
+        metadata: IPropertyMetadata,
+        definitions?: Record<string, ISchema>
+    ): IPolymorphicVariant[] {
+        const rawList = metadata.oneOf || metadata.anyOf || [];
+        const discProp = metadata.discriminator?.propertyName;
+        const discMapping = metadata.discriminator?.mapping;
+        const baseProps = metadata.properties || {};
+        const result: IPolymorphicVariant[] = [];
+
+        const usedKeys = new Set<string>();
+
+        rawList.forEach((branch, idx) => {
+            let resolvedBranch: IPropertyMetadata = deepClone(branch);
+            let refName: string | undefined;
+
+            if (branch.$ref) {
+                refName = OpenApiRefResolver.extractRefName(branch.$ref);
+                const defSchema = definitions?.[refName];
+                if (defSchema) {
+                    resolvedBranch = {
+                        ...resolvedBranch,
+                        title: branch.title || defSchema.title || refName,
+                        required: Array.isArray(defSchema.required) ? defSchema.required : resolvedBranch.required,
+                        properties: {
+                            ...(defSchema.properties ? deepClone(defSchema.properties) : {}),
+                            ...(resolvedBranch.properties || {})
+                        }
+                    };
+                }
+            }
+
+            const mergedProps: Record<string, IPropertyMetadata> = {
+                ...deepClone(baseProps),
+                ...(resolvedBranch.properties || {})
+            };
+
+            if (Array.isArray(resolvedBranch.required)) {
+                for (const reqKey of resolvedBranch.required) {
+                    if (mergedProps[reqKey]) {
+                        mergedProps[reqKey] = { ...mergedProps[reqKey], required: true };
+                    }
+                }
+            }
+
+            let key = this.resolveDiscriminatorKey(discProp, discMapping, branch.$ref, refName, resolvedBranch, mergedProps, idx);
+            if (usedKeys.has(key)) {
+                key = `${key}_${idx + 1}`;
+            }
+            usedKeys.add(key);
+            const title = resolvedBranch.title || resolvedBranch.ui?.label || refName || `Variant ${idx + 1}`;
+            result.push({ key, title, properties: mergedProps });
+        });
+
+        if (result.length === 0 && Object.keys(baseProps).length > 0) {
+            result.push({
+                key: "default",
+                title: metadata.ui?.label || metadata.title || "Default",
+                properties: deepClone(baseProps)
+            });
+        }
+
+        return result;
+    }
+
+    /**
+     * Determines the canonical variant key from discriminator mappings, `const`/`enum` constraints, or property names.
+     *
+     * @param discProp Optional discriminator property name.
+     * @param discMapping Optional OpenAPI discriminator mapping dictionary.
+     * @param rawRef Optional raw `$ref` string on the branch.
+     * @param refName Optional short `$ref` target name.
+     * @param resolvedBranch The resolved branch metadata.
+     * @param mergedProps Merged properties for the branch.
+     * @param idx Fallback 0-based branch index.
+     * @returns {string} The canonical variant key.
+     */
+    private static resolveDiscriminatorKey(
+        discProp: string | undefined,
+        discMapping: Record<string, string> | undefined,
+        rawRef: string | undefined,
+        refName: string | undefined,
+        resolvedBranch: IPropertyMetadata,
+        mergedProps: Record<string, IPropertyMetadata>,
+        idx: number
+    ): string {
+        if (discMapping && rawRef) {
+            for (const [mapKey, mapTarget] of Object.entries(discMapping)) {
+                if (mapTarget === rawRef || mapTarget === refName) {
+                    return mapKey;
+                }
+            }
+        }
+        if (discProp && mergedProps[discProp]) {
+            const discMeta = mergedProps[discProp];
+            if (typeof discMeta.const === "string" && discMeta.const) {
+                return discMeta.const;
+            }
+            if (Array.isArray(discMeta.enum) && discMeta.enum.length > 0) {
+                return String(discMeta.enum[0]);
+            }
+        } else if (!discProp) {
+            const propKeys = Object.keys(resolvedBranch.properties || {});
+            if (propKeys.length === 1) {
+                return propKeys[0];
+            }
+        }
+        return refName || resolvedBranch.title || `Variant_${idx}`;
+    }
+
+    /**
+     * Detects which variant key matches a runtime data object.
+     *
+     * @param variants Available polymorphic variants.
+     * @param currentObj The current bound object from the model.
+     * @param discProp Optional discriminator property name.
+     * @returns {string} The active variant key.
+     */
+    public static detectActiveVariantKey(
+        variants: IPolymorphicVariant[],
+        currentObj: unknown,
+        discProp?: string
+    ): string {
+        if (variants.length === 0) {
+            return "";
+        }
+        if (isRecord(currentObj)) {
+            if (discProp) {
+                const discVal = readString(currentObj, discProp);
+                if (discVal && variants.some((v) => v.key === discVal)) {
+                    return discVal;
+                }
+            }
+            for (const variant of variants) {
+                const uniqueKeys = Object.keys(variant.properties).filter((k) => k !== discProp);
+                if (uniqueKeys.some((k) => currentObj[k] !== undefined)) {
+                    return variant.key;
+                }
+            }
+        }
+        return variants[0].key;
+    }
+
+    /**
+     * Merges polymorphic `oneOf` or `anyOf` root branch properties into a root or definition `ISchema`,
+     * populating discriminator enum/valueHelp options when a discriminator property is present.
+     *
+     * @param schema The target `ISchema` to enrich.
+     * @param rootMeta The normalized root property metadata holding `oneOf`/`anyOf`/`discriminator`.
+     */
+    public static mergePolymorphicRootBranches(schema: ISchema, rootMeta: IPropertyMetadata): void {
+        const branches = rootMeta.oneOf || rootMeta.anyOf;
+        if (!branches || branches.length === 0) return;
+        schema.properties = schema.properties || {};
+        const discProp = rootMeta.discriminator?.propertyName;
+        const variantKeys: string[] = [];
+        for (const branch of branches) {
+            if (branch.title) variantKeys.push(branch.title);
+            if (branch.properties) {
+                for (const [propKey, propMeta] of Object.entries(branch.properties)) {
+                    if (!schema.properties[propKey]) {
+                        schema.properties[propKey] = { ...propMeta, required: false };
+                    }
+                }
+            }
+        }
+        if (discProp && schema.properties[discProp] && variantKeys.length > 0 && !schema.properties[discProp].enum) {
+            schema.properties[discProp].enum = variantKeys;
+            schema.properties[discProp].valueHelp = variantKeys.map((k) => ({ key: k, text: k }));
+            schema.properties[discProp].ui = {
+                ...(schema.properties[discProp].ui || {}),
+                widget: WIDGET_TYPE.SELECT,
+                valueHelp: schema.properties[discProp].valueHelp
+            };
+        }
+    }
+
+    /**
+     * Ensures the bound model object at `targetPath` has the active variant's discriminator, `const`, and `default` values initialized.
+     *
+     * @param model Optional `JSONModel` instance.
+     * @param targetPath Resolved absolute model path.
+     * @param variants Available polymorphic variants.
+     * @param variantKey The active variant key.
+     * @param discProp Optional discriminator property name.
+     */
+    public static ensureVariantDefaults(
+        model: JSONModel | undefined,
+        targetPath: string,
+        variants: IPolymorphicVariant[],
+        variantKey: string,
+        discProp?: string
+    ): void {
+        if (!model || !variantKey) return;
+        const currentObj = model.getProperty(targetPath);
+        if (!isRecord(currentObj)) return;
+        const selectedVariant = variants.find((v) => v.key === variantKey);
+        if (!selectedVariant) return;
+        let mutated = false;
+        const nextObj: Record<string, unknown> = { ...currentObj };
+        if (discProp && nextObj[discProp] === undefined) {
+            nextObj[discProp] = variantKey;
+            mutated = true;
+        }
+        for (const [propKey, propMeta] of Object.entries(selectedVariant.properties)) {
+            if (propMeta.const !== undefined && nextObj[propKey] !== propMeta.const) {
+                nextObj[propKey] = propMeta.const;
+                mutated = true;
+            } else if (nextObj[propKey] === undefined && propMeta.default !== undefined) {
+                nextObj[propKey] = propMeta.default;
+                mutated = true;
+            }
+        }
+        if (mutated) {
+            model.setProperty(targetPath, nextObj);
+        }
+    }
+
+    /**
+     * Prunes stale variant keys and injects `const`/`default`/discriminator values on the bound model when switching variants.
+     *
+     * @param model Optional `JSONModel` instance.
+     * @param targetPath Resolved absolute model path.
+     * @param variants Available polymorphic variants.
+     * @param newKey Newly selected variant key.
+     * @param discProp Optional discriminator property name.
+     */
+    public static applyVariantSwitch(
+        model: JSONModel | undefined,
+        targetPath: string,
+        variants: IPolymorphicVariant[],
+        newKey: string,
+        discProp?: string
+    ): void {
+        if (!model) return;
+        const currentObj = model.getProperty(targetPath);
+        const nextObj: Record<string, unknown> = isRecord(currentObj) ? { ...currentObj } : {};
+        const selectedVariant = variants.find((v) => v.key === newKey);
+        if (selectedVariant) {
+            const allowedKeys = new Set<string>(Object.keys(selectedVariant.properties));
+            if (discProp) allowedKeys.add(discProp);
+            for (const otherVariant of variants) {
+                if (otherVariant.key === newKey) continue;
+                for (const staleKey of Object.keys(otherVariant.properties)) {
+                    if (!allowedKeys.has(staleKey)) delete nextObj[staleKey];
+                }
+            }
+            for (const [propKey, propMeta] of Object.entries(selectedVariant.properties)) {
+                if (propMeta.const !== undefined) nextObj[propKey] = propMeta.const;
+                else if (nextObj[propKey] === undefined && propMeta.default !== undefined) nextObj[propKey] = propMeta.default;
+            }
+        }
+        if (discProp) nextObj[discProp] = newKey;
+        model.setProperty(targetPath, nextObj);
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/utils/TypeGuards.ts

@@ -0,0 +1,151 @@
+/**
+ * @file TypeGuards.ts
+ * @description Shared runtime type guards for narrowing untrusted input (raw JSON schemas,
+ * consumer payloads, OpenAPI documents) without resorting to unchecked casts.
+ *
+ * Every MetaUI module that ingests external JSON must narrow it through these guards so the
+ * compiler can prove property access is safe.
+ */
+
+import { MAX_CLONE_DEPTH } from "../constants/MetaUIConstants";
+import { Logger } from "./Logger";
+
+/** A plain JSON object (not null, not an array). */
+export type JsonRecord = Record<string, unknown>;
+
+/**
+ * Checks whether a value is a plain, non-null, non-array object.
+ *
+ * @param value The value to inspect.
+ * @returns True if the value can be safely indexed by string keys.
+ */
+export function isRecord(value: unknown): value is JsonRecord {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+
+/**
+ * Reads a string property from a record.
+ *
+ * @param record The source record.
+ * @param key The property name.
+ * @returns The string value, or undefined if missing or not a string.
+ */
+export function readString(record: JsonRecord, key: string): string | undefined {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+
+/**
+ * Reads a finite numeric property from a record.
+ *
+ * @param record The source record.
+ * @param key The property name.
+ * @returns The number, or undefined if missing or not a finite number.
+ */
+export function readNumber(record: JsonRecord, key: string): number | undefined {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+/**
+ * Reads a boolean property from a record.
+ *
+ * @param record The source record.
+ * @param key The property name.
+ * @returns The boolean, or undefined if missing or not a boolean.
+ */
+export function readBoolean(record: JsonRecord, key: string): boolean | undefined {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+
+/**
+ * Reads a nested object property from a record.
+ *
+ * @param record The source record.
+ * @param key The property name.
+ * @returns The nested record, or undefined if missing or not a plain object.
+ */
+export function readRecord(record: JsonRecord, key: string): JsonRecord | undefined {
+    const value = record[key];
+    return isRecord(value) ? value : undefined;
+}
+
+/**
+ * Reads an array of strings from a record, discarding non-string entries.
+ *
+ * @param record The source record.
+ * @param key The property name.
+ * @returns The string array, or undefined if the property is not an array.
+ */
+export function readStringArray(record: JsonRecord, key: string): string[] | undefined {
+    const value = record[key];
+    if (!Array.isArray(value)) return undefined;
+    return value.filter((entry): entry is string => typeof entry === "string");
+}
+
+/**
+ * Produces a deep, cycle-safe clone of a value while preserving `Date` instances.
+ * Used to enforce the MetaUI sandbox: consumer-owned objects must never be mutated by the engine.
+ *
+ * @param value The value to clone.
+ * @param seen Internal WeakMap tracking visited object references to guard against circular graphs.
+ * @returns A structurally identical copy that shares no references with the input.
+ */
+export function deepClone<T>(value: T, seen: WeakMap<object, unknown> = new WeakMap()): T {
+    return cloneInternal(value, seen, 0) as T;
+}
+
+
+function cloneInternal(value: unknown, seen: WeakMap<object, unknown>, depth: number): unknown {
+    if (value === undefined || value === null || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    // WALKER_EXEMPT: cloneInternal copies arbitrary untyped JavaScript graphs (Dates, arrays, plain objects, __proto__
+    // own-properties) capped at MAX_CLONE_DEPTH rather than MAX_SCHEMA_DEPTH, and must register the newly allocated copy
+    // in seen: WeakMap<object, unknown> (seen.set(value, copy)) before descending so cycle back-edges return that exact
+    // allocated reference via seen.get(value), whereas SchemaWalker truncates cycles without returning a synthesized value
+    // and itself depends on deepClone from this module.
+    if (depth >= MAX_CLONE_DEPTH) {
+        // Returning {} or [] here replaces the consumer's own data with nothing. That is the
+        // most expensive silent truncation in the library, so it must never be silent.
+        Logger.warn(
+            `deepClone exceeded MAX_CLONE_DEPTH (${MAX_CLONE_DEPTH}); the payload below this level was ` +
+            `replaced with an empty ${Array.isArray(value) ? "array" : "object"} and its data is lost.`,
+            undefined,
+            "TypeGuards"
+        );
+        return Array.isArray(value) ? [] : {};
+    }
+    if (Array.isArray(value)) {
+        const copy: unknown[] = [];
+        seen.set(value, copy);
+        for (let i = 0; i < value.length; i++) {
+            copy[i] = cloneInternal(value[i], seen, depth + 1);
+        }
+        return copy;
+    }
+    const source = value as Record<string, unknown>;
+    const copy: Record<string, unknown> = {};
+    seen.set(value, copy);
+    for (const key of Object.keys(source)) {
+        const clonedVal = cloneInternal(source[key], seen, depth + 1);
+        if (key === "__proto__") {
+            Object.defineProperty(copy, key, {
+                value: clonedVal,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        } else {
+            copy[key] = clonedVal;
+        }
+    }
+    return copy;
+}