@fluidframework/runtime-utils 2.53.1 → 2.60.0

package/src/objectstoragepartition.ts

@@ -4,14 +4,14 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
+import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 
 /**
  * Returns a new IChannelStorageService that resolves the given `path` as root.
  * @internal
  */
 export class ObjectStoragePartition implements IChannelStorageService {
-	constructor(
+	public constructor(
 		private readonly storage: IChannelStorageService,
 		private readonly path: string,
 	) {

package/src/objectstorageutils.ts

@@ -3,18 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { ITree } from "@fluidframework/driver-definitions/internal";
+import type { ITree } from "@fluidframework/driver-definitions/internal";
+import { TreeEntry } from "@fluidframework/driver-definitions/internal";
 
 /**
+ * Normalizes a storage path by removing leading and trailing slashes and splitting into parts
+ * @param path - The storage path to normalize (e.g. "/foo/bar/")
+ * @returns Array of path segments (e.g. ["foo", "bar"])
  * @internal
  */
-export function getNormalizedObjectStoragePathParts(path: string) {
+export function getNormalizedObjectStoragePathParts(path: string): string[] {
 	let normalizePath = path;
 	if (normalizePath.startsWith("/")) {
-		normalizePath = normalizePath.substr(1);
+		normalizePath = normalizePath.slice(1);
 	}
 	if (normalizePath.endsWith("/")) {
-		normalizePath = normalizePath.substr(0, normalizePath.length - 1);
+		normalizePath = normalizePath.slice(0, -1);
 	}
 	if (normalizePath.length > 0) {
 		return normalizePath.split("/");
@@ -23,6 +27,11 @@ export function getNormalizedObjectStoragePathParts(path: string) {
 }
 
 /**
+ * Lists all blobs at the specified path in the given tree
+ * @param inputTree - The tree to search within
+ * @param path - The path to search at (e.g. "foo/bar")
+ * @returns Promise that resolves to an array of blob names at that path
+ * @throws Error if the path does not exist in the tree
  * @internal
  */
 export async function listBlobsAtTreePath(
@@ -34,16 +43,16 @@ export async function listBlobsAtTreePath(
 	while (tree?.entries !== undefined && pathParts.length > 0) {
 		const part = pathParts.shift();
 		const treeEntry = tree.entries.find((value) => {
-			return value.type === "Tree" && value.path === part ? true : false;
+			return value.type === TreeEntry.Tree && value.path === part ? true : false;
 		});
 
 		// this check is largely superfluous due to the same check being done
 		// immediately above. the type system, however, is not aware of this.
 		// so we must redundantly determine that the entry's type is "Tree"
-		tree = treeEntry?.type === "Tree" ? treeEntry.value : undefined;
+		tree = treeEntry?.type === TreeEntry.Tree ? treeEntry.value : undefined;
 	}
-	if (tree?.entries === undefined || pathParts.length !== 0) {
+	if (tree?.entries === undefined || pathParts.length > 0) {
 		throw new Error("path does not exist");
 	}
-	return tree.entries.filter((e) => e.type === "Blob").map((e) => e.path);
+	return tree.entries.filter((e) => e.type === TreeEntry.Blob).map((e) => e.path);
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/runtime-utils";
-export const pkgVersion = "2.53.1";
+export const pkgVersion = "2.60.0";

package/src/remoteFluidObjectHandle.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { FluidObject, IRequest } from "@fluidframework/core-interfaces";
-import { IFluidHandleContext } from "@fluidframework/core-interfaces/internal";
+import type { FluidObject, IRequest } from "@fluidframework/core-interfaces";
+import type { IFluidHandleContext } from "@fluidframework/core-interfaces/internal";
 import { assert } from "@fluidframework/core-utils/internal";
 
 import { responseToException } from "./dataStoreHelpers.js";
@@ -30,7 +30,7 @@ export class RemoteFluidObjectHandle extends FluidHandleBase<FluidObject> {
 	 * @param routeContext - The root IFluidHandleContext that has a route to this handle.
 	 * @param payloadPending - Whether the handle may have a pending payload that is not yet available.
 	 */
-	constructor(
+	public constructor(
 		public readonly absolutePath: string,
 		public readonly routeContext: IFluidHandleContext,
 		public readonly payloadPending: boolean,
@@ -54,6 +54,7 @@ export class RemoteFluidObjectHandle extends FluidHandleBase<FluidObject> {
 			};
 			this.objectP = this.routeContext.resolveHandle(request).then<FluidObject>((response) => {
 				if (response.mimeType === "fluid/object") {
+					// Responses with mimeType == "fluid/object" are produced by Fluid, and thus they can reasonably be expected to always be a FluidObject
 					const fluidObject: FluidObject = response.value as FluidObject;
 					return fluidObject;
 				}

package/src/requestParser.ts

@@ -3,12 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
+import type { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
 
 /**
  * The Request Parser takes an IRequest provides parsing and sub request creation
- * @legacy
- * @alpha
+ * @legacy @beta
  */
 export class RequestParser implements IRequest {
 	/**
@@ -17,21 +16,22 @@ export class RequestParser implements IRequest {
 	 */
 	public static getPathParts(url: string): readonly string[] {
 		const queryStartIndex = url.indexOf("?");
-		return url
-			.substring(0, queryStartIndex < 0 ? url.length : queryStartIndex)
-			.split("/")
-			.reduce<string[]>((pv, cv) => {
-				if (cv !== undefined && cv.length > 0) {
-					pv.push(decodeURIComponent(cv));
-				}
-				return pv;
-			}, []);
+		const pathParts: string[] = [];
+		const urlPath = url.slice(0, queryStartIndex < 0 ? url.length : queryStartIndex);
+
+		for (const part of urlPath.split("/")) {
+			if (part !== undefined && part.length > 0) {
+				pathParts.push(decodeURIComponent(part));
+			}
+		}
+
+		return pathParts;
 	}
 
 	private requestPathParts: readonly string[] | undefined;
 	public readonly query: string;
 
-	public static create(request: Readonly<IRequest>) {
+	public static create(request: Readonly<IRequest>): RequestParser {
 		// Perf optimizations.
 		if (request instanceof RequestParser) {
 			return request;
@@ -41,7 +41,7 @@ export class RequestParser implements IRequest {
 
 	protected constructor(private readonly request: Readonly<IRequest>) {
 		const queryStartIndex = this.request.url.indexOf("?");
-		this.query = queryStartIndex >= 0 ? this.request.url.substring(queryStartIndex) : "";
+		this.query = queryStartIndex >= 0 ? this.request.url.slice(queryStartIndex) : "";
 		if (request.headers !== undefined) {
 			this.headers = request.headers;
 		}
@@ -67,7 +67,7 @@ export class RequestParser implements IRequest {
 	 * Returns true if it's a terminating path, i.e. no more elements after `elements` entries and empty query.
 	 * @param elements - number of elements in path
 	 */
-	public isLeaf(elements: number) {
+	public isLeaf(elements: number): boolean {
 		return this.query === "" && this.pathParts.length === elements;
 	}
 

package/src/runtimeFactoryHelper.ts

@@ -3,19 +3,18 @@
  * Licensed under the MIT License.
  */
 
-import {
+import type {
 	IContainerContext,
 	IRuntime,
 	IRuntimeFactory,
 } from "@fluidframework/container-definitions/internal";
-import { IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
+import type { IContainerRuntime } from "@fluidframework/container-runtime-definitions/internal";
 
 /**
- * @legacy
- * @alpha
+ * @legacy @beta
  */
 export abstract class RuntimeFactoryHelper<T = IContainerRuntime> implements IRuntimeFactory {
-	public get IRuntimeFactory() {
+	public get IRuntimeFactory(): this {
 		return this;
 	}
 

package/src/summaryUtils.ts

@@ -9,29 +9,30 @@ import {
 	bufferToString,
 	fromBase64ToUtf8,
 } from "@fluid-internal/client-utils";
-import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions/internal";
+import type { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions/internal";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import {
+import type {
 	ISummaryBlob,
 	ISummaryTree,
 	SummaryObject,
-	SummaryType,
 } from "@fluidframework/driver-definitions";
-import { ITree, ITreeEntry, TreeEntry } from "@fluidframework/driver-definitions/internal";
+import { SummaryType } from "@fluidframework/driver-definitions";
+import type { ITree, ITreeEntry } from "@fluidframework/driver-definitions/internal";
+import { TreeEntry } from "@fluidframework/driver-definitions/internal";
 import {
 	AttachmentTreeEntry,
 	BlobTreeEntry,
 	TreeTreeEntry,
 } from "@fluidframework/driver-utils/internal";
-import {
+import type {
 	ISummaryStats,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 	IGarbageCollectionData,
 	ISummarizeResult,
 	ITelemetryContextExt,
-	gcDataBlobKey,
 } from "@fluidframework/runtime-definitions/internal";
+import { gcDataBlobKey } from "@fluidframework/runtime-definitions/internal";
 import type { TelemetryEventPropertyTypeExt } from "@fluidframework/telemetry-utils/internal";
 
 /**
@@ -59,26 +60,34 @@ export function mergeStats(...stats: ISummaryStats[]): ISummaryStats {
 }
 
 /**
+ * Calculates the byte length of an UTF-8 encoded string
+ * @param str - The string to calculate the byte length of
+ * @returns The byte length of the string
  * @internal
  */
 export function utf8ByteLength(str: string): number {
 	// returns the byte length of an utf8 string
 	let s = str.length;
 	for (let i = str.length - 1; i >= 0; i--) {
-		const code = str.charCodeAt(i);
-		if (code > 0x7f && code <= 0x7ff) {
-			s++;
-		} else if (code > 0x7ff && code <= 0xffff) {
-			s += 2;
-		}
-		if (code >= 0xdc00 && code <= 0xdfff) {
-			i--; // trail surrogate
+		const code = str.codePointAt(i);
+		if (code !== undefined) {
+			if (code > 0x7f && code <= 0x7ff) {
+				s++;
+			} else if (code > 0x7ff && code <= 0xffff) {
+				s += 2;
+			}
+			if (code >= 0xdc00 && code <= 0xdfff) {
+				i--; // trail surrogate
+			}
 		}
 	}
 	return s;
 }
 
 /**
+ * Gets the size of a blob
+ * @param content - The content of the blob
+ * @returns The size of the blob in bytes
  * @internal
  */
 export function getBlobSize(content: ISummaryBlob["content"]): number {
@@ -103,12 +112,16 @@ function calculateStatsCore(summaryObject: SummaryObject, stats: ISummaryStats):
 			stats.totalBlobSize += getBlobSize(summaryObject.content);
 			return;
 		}
-		default:
+		default: {
 			return;
+		}
 	}
 }
 
 /**
+ * Calculates the stats for a summary object
+ * @param summary - The summary object to calculate stats for
+ * @returns The calculated stats
  * @internal
  */
 export function calculateStats(summary: SummaryObject): ISummaryStats {
@@ -118,6 +131,10 @@ export function calculateStats(summary: SummaryObject): ISummaryStats {
 }
 
 /**
+ * Adds a blob to the summary tree
+ * @param summary - The summary tree to add the blob to
+ * @param key - The key to store the blob at
+ * @param content - The content of the blob to be added
  * @internal
  */
 export function addBlobToSummary(
@@ -135,6 +152,10 @@ export function addBlobToSummary(
 }
 
 /**
+ * Adds a summarize result to the summary tree
+ * @param summary - The summary tree to add the summarize result to
+ * @param key - The key to store the summarize result at
+ * @param summarizeResult - The summarize result to be added
  * @internal
  */
 export function addSummarizeResultToSummary(
@@ -148,8 +169,7 @@ export function addSummarizeResultToSummary(
 
 /**
  * An object who's properties are used to initialize a {@link SummaryTreeBuilder}
- * @legacy
- * @alpha
+ * @legacy @beta
  */
 export interface SummaryTreeBuilderParams {
 	/**
@@ -161,8 +181,7 @@ export interface SummaryTreeBuilderParams {
 /**
  * A helper class for building summary trees.
  * @remarks Uses the builder pattern.
- * @legacy
- * @alpha
+ * @legacy @beta
  */
 export class SummaryTreeBuilder implements ISummaryTreeWithStats {
 	private attachmentCounter: number = 0;
@@ -183,13 +202,13 @@ export class SummaryTreeBuilder implements ISummaryTreeWithStats {
 		return { ...this.summaryStats };
 	}
 
-	constructor(params?: { groupId?: string }) {
+	public constructor(params?: { groupId?: string }) {
 		this.summaryStats = mergeStats();
 		this.summaryStats.treeNodeCount++;
 		this.groupId = params?.groupId;
 	}
 
-	private readonly summaryTree: { [path: string]: SummaryObject } = {};
+	private readonly summaryTree: Record<string, SummaryObject> = {};
 	private summaryStats: ISummaryStats;
 
 	/**
@@ -247,7 +266,7 @@ export class SummaryTreeBuilder implements ISummaryTreeWithStats {
 	 * Adds an {@link @fluidframework/driver-definitions#ISummaryAttachment} to the summary. This blob needs to already be uploaded to storage.
 	 * @param id - The id of the uploaded attachment to be added to the summary tree.
 	 */
-	public addAttachment(id: string) {
+	public addAttachment(id: string): void {
 		this.summaryTree[this.attachmentCounter++] = { id, type: SummaryType.Attachment };
 	}
 
@@ -267,8 +286,7 @@ export class SummaryTreeBuilder implements ISummaryTreeWithStats {
  * Converts snapshot ITree to ISummaryTree format and tracks stats.
  * @param snapshot - snapshot in ITree format
  * @param fullTree - true to never use handles, even if id is specified
- * @legacy
- * @alpha
+ * @legacy @beta
  */
 export function convertToSummaryTreeWithStats(
 	snapshot: ITree,
@@ -299,8 +317,9 @@ export function convertToSummaryTreeWithStats(
 				break;
 			}
 
-			default:
+			default: {
 				throw new Error("Unexpected TreeEntry type");
+			}
 		}
 	}
 
@@ -354,6 +373,8 @@ export function convertSnapshotTreeToSummaryTree(
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			const content: ArrayBufferLike = snapshot.blobsContents[id]!;
 			if (content !== undefined) {
+				// Cannot change "utf-8" to "utf8" as this encoding value is stored in summaries and would be a breaking change which needs to be done first before changing to utf8.
+				// eslint-disable-next-line unicorn/text-encoding-identifier-case -- External on-disk format is 'utf-8'.
 				decoded = bufferToString(content, "utf-8");
 			}
 			// 0.44 back-compat We still put contents in same blob for back-compat so need to add blob
@@ -390,6 +411,8 @@ export function convertSummaryTreeToITree(summaryTree: ISummaryTree): ITree {
 		switch (value.type) {
 			case SummaryType.Blob: {
 				let parsedContent: string;
+				// Cannot change "utf-8" to "utf8" as this encoding value is stored in summaries and would be a breaking change which needs to be done first before changing to utf8.
+				// eslint-disable-next-line unicorn/text-encoding-identifier-case -- external contract uses 'utf-8'.
 				let encoding: "utf-8" | "base64" = "utf-8";
 				if (typeof value.content === "string") {
 					parsedContent = value.content;
@@ -415,8 +438,9 @@ export function convertSummaryTreeToITree(summaryTree: ISummaryTree): ITree {
 				throw new Error("Should not have Handle type in summary tree");
 			}
 
-			default:
+			default: {
 				unreachableCase(value, "Unexpected summary tree type");
+			}
 		}
 	}
 	return {
@@ -440,7 +464,7 @@ export function convertSummaryTreeToITree(summaryTree: ISummaryTree): ITree {
  * @internal
  */
 export function processAttachMessageGCData(
-	snapshot: ITree | null,
+	snapshot: ITree | undefined,
 	addedGCOutboundRoute: (fromNodeId: string, toPath: string) => void,
 ): boolean {
 	const gcDataEntry = snapshot?.entries.find((e) => e.path === gcDataBlobKey);
@@ -452,15 +476,18 @@ export function processAttachMessageGCData(
 	}
 
 	assert(
+		// Cannot change "utf-8" to "utf8" as this encoding value is stored in summaries and would be a breaking change which needs to be done first before changing to utf8.
+		// eslint-disable-next-line unicorn/text-encoding-identifier-case  -- external contract uses 'utf-8'.
 		gcDataEntry.type === TreeEntry.Blob && gcDataEntry.value.encoding === "utf-8",
 		0x8ff /* GC data should be a utf-8-encoded blob */,
 	);
 
+	// Type assertion is safe as we expect the GC data to conform to IGarbageCollectionData schema
 	const gcData = JSON.parse(gcDataEntry.value.contents) as IGarbageCollectionData;
 	for (const [nodeId, outboundRoutes] of Object.entries(gcData.gcNodes)) {
-		outboundRoutes.forEach((toPath) => {
+		for (const toPath of outboundRoutes) {
 			addedGCOutboundRoute(nodeId, toPath);
-		});
+		}
 	}
 	return true;
 }
@@ -474,14 +501,14 @@ export class TelemetryContext implements ITelemetryContext, ITelemetryContextExt
 	/**
 	 * {@inheritDoc @fluidframework/runtime-definitions#ITelemetryContext.set}
 	 */
-	set(prefix: string, property: string, value: TelemetryEventPropertyTypeExt): void {
+	public set(prefix: string, property: string, value: TelemetryEventPropertyTypeExt): void {
 		this.telemetry.set(`${prefix}${property}`, value);
 	}
 
 	/**
 	 * {@inheritDoc @fluidframework/runtime-definitions#ITelemetryContext.setMultiple}
 	 */
-	setMultiple(
+	public setMultiple(
 		prefix: string,
 		property: string,
 		values: Record<string, TelemetryEventPropertyTypeExt>,
@@ -495,18 +522,18 @@ export class TelemetryContext implements ITelemetryContext, ITelemetryContextExt
 	/**
 	 * {@inheritDoc @fluidframework/runtime-definitions#ITelemetryContext.get}
 	 */
-	get(prefix: string, property: string): TelemetryEventPropertyTypeExt {
+	public get(prefix: string, property: string): TelemetryEventPropertyTypeExt {
 		return this.telemetry.get(`${prefix}${property}`);
 	}
 
 	/**
 	 * {@inheritDoc @fluidframework/runtime-definitions#ITelemetryContext.serialize}
 	 */
-	serialize(): string {
+	public serialize(): string {
 		const jsonObject = {};
-		this.telemetry.forEach((value, key) => {
+		for (const [key, value] of this.telemetry.entries()) {
 			jsonObject[key] = value;
-		});
+		}
 		return JSON.stringify(jsonObject);
 	}
 }
@@ -516,7 +543,7 @@ export class TelemetryContext implements ITelemetryContext, ITelemetryContextExt
  * @param str - A string that may contain leading slashes.
  * @returns A new string without leading slashes.
  */
-function trimLeadingSlashes(str: string) {
+function trimLeadingSlashes(str: string): string {
 	return str.replace(/^\/+/g, "");
 }
 
@@ -525,7 +552,7 @@ function trimLeadingSlashes(str: string) {
  * @param str - A string that may contain trailing slashes.
  * @returns A new string without trailing slashes.
  */
-function trimTrailingSlashes(str: string) {
+function trimTrailingSlashes(str: string): string {
 	return str.replace(/\/+$/g, "");
 }
 
@@ -534,8 +561,8 @@ function trimTrailingSlashes(str: string) {
  * @internal
  */
 export class GCDataBuilder implements IGarbageCollectionData {
-	private readonly gcNodesSet: { [id: string]: Set<string> } = {};
-	public get gcNodes(): { [id: string]: string[] } {
+	private readonly gcNodesSet: Record<string, Set<string>> = {};
+	public get gcNodes(): Record<string, string[]> {
 		const gcNodes = {};
 		for (const [nodeId, outboundRoutes] of Object.entries(this.gcNodesSet)) {
 			gcNodes[nodeId] = [...outboundRoutes];
@@ -543,7 +570,7 @@ export class GCDataBuilder implements IGarbageCollectionData {
 		return gcNodes;
 	}
 
-	public addNode(id: string, outboundRoutes: string[]) {
+	public addNode(id: string, outboundRoutes: string[]): void {
 		this.gcNodesSet[id] = new Set(outboundRoutes);
 	}
 
@@ -553,7 +580,7 @@ export class GCDataBuilder implements IGarbageCollectionData {
 	 * - Prefixes the given `prefixId` to the given nodes' ids.
 	 * - Adds the outbound routes of the nodes against the normalized and prefixed id.
 	 */
-	public prefixAndAddNodes(prefixId: string, gcNodes: { [id: string]: string[] }) {
+	public prefixAndAddNodes(prefixId: string, gcNodes: Record<string, string[]>): void {
 		for (const [id, outboundRoutes] of Object.entries(gcNodes)) {
 			// Remove any leading slashes from the id.
 			let normalizedId = trimLeadingSlashes(id);
@@ -568,7 +595,7 @@ export class GCDataBuilder implements IGarbageCollectionData {
 		}
 	}
 
-	public addNodes(gcNodes: { [id: string]: string[] }) {
+	public addNodes(gcNodes: Record<string, string[]>): void {
 		for (const [id, outboundRoutes] of Object.entries(gcNodes)) {
 			this.gcNodesSet[id] = new Set(outboundRoutes);
 		}
@@ -577,7 +604,7 @@ export class GCDataBuilder implements IGarbageCollectionData {
 	/**
 	 * Adds the given outbound route to the outbound routes of all GC nodes.
 	 */
-	public addRouteToAllNodes(outboundRoute: string) {
+	public addRouteToAllNodes(outboundRoute: string): void {
 		for (const outboundRoutes of Object.values(this.gcNodesSet)) {
 			outboundRoutes.add(outboundRoute);
 		}

package/src/unpackUsedRoutes.ts

@@ -11,10 +11,12 @@ import { assert } from "@fluidframework/core-utils/internal";
  * @returns A map of used routes of each children of the the given node.
  * @internal
  */
-export function unpackChildNodesUsedRoutes(usedRoutes: readonly string[]) {
+export function unpackChildNodesUsedRoutes(
+	usedRoutes: readonly string[],
+): Map<string, string[]> {
 	// Remove the node's self used route, if any, and generate the children used routes.
 	const filteredUsedRoutes = usedRoutes.filter((route) => route !== "" && route !== "/");
-	const childUsedRoutesMap: Map<string, string[]> = new Map();
+	const childUsedRoutesMap = new Map<string, string[]>();
 	for (const route of filteredUsedRoutes) {
 		assert(route.startsWith("/"), 0x5e0 /* Used route should always be an absolute route */);
 		const childId = route.split("/")[1];
@@ -25,10 +27,10 @@ export function unpackChildNodesUsedRoutes(usedRoutes: readonly string[]) {
 		const childUsedRoute = route.slice(childId.length + 1);
 
 		const childUsedRoutes = childUsedRoutesMap.get(childId);
-		if (childUsedRoutes !== undefined) {
-			childUsedRoutes.push(childUsedRoute);
-		} else {
+		if (childUsedRoutes === undefined) {
 			childUsedRoutesMap.set(childId, [childUsedRoute]);
+		} else {
+			childUsedRoutes.push(childUsedRoute);
 		}
 	}
 	return childUsedRoutesMap;

package/src/utils.ts

@@ -4,7 +4,7 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import {
+import type {
 	IDocumentAttributes,
 	ISnapshotTree,
 } from "@fluidframework/driver-definitions/internal";
@@ -77,7 +77,7 @@ export const charSetForEncodingIds =
  * @returns A string - representation of an input
  * @internal
  */
-export function encodeCompactIdToString(idArg: number | string, prefix = "") {
+export function encodeCompactIdToString(idArg: number | string, prefix = ""): string {
 	if (typeof idArg === "string") {
 		return idArg;
 	}