@futdevpro/fsm-dynamo 1.9.46 → 1.9.48

package/src/_collections/utils/array.util.spec.ts

@@ -1,5 +1,6 @@
 
 
+import { DyFM_Paged } from '../../_models/interfaces/paged.interface';
 import { DyFM_Array } from './array.util';
 import { DyFM_delay } from './utilities.util';
 
@@ -7,7 +8,7 @@ describe('DyFM_Array', (): void => {
 
   describe('asyncForEach', (): void => {
     it('should call the function for each element in the list', async (): Promise<void> => {
-      const list = [1, 2, 3];
+      const list = [ 1, 2, 3 ];
       const result = [];
       const func = async (e, i): Promise<void> => { 
         await DyFM_delay(30);
@@ -22,7 +23,7 @@ describe('DyFM_Array', (): void => {
 
   describe('asyncMapArray', (): void => {
     it('should call the function for each element in the list', async (): Promise<void> => {
-      const list = [1, 2, 3];
+      const list = [ 1, 2, 3 ];
       
       const func = async (e, i): Promise<number> => { 
         await DyFM_delay(30);
@@ -32,8 +33,321 @@ describe('DyFM_Array', (): void => {
 
       const result = await DyFM_Array.asyncMap(list, func);
 
-      expect(result).toEqual([2, 4, 6]);
+      expect(result).toEqual([ 2, 4, 6 ]);
     });
   });
+  
+  describe('shuffle', () => {
+    it('should shuffle the elements in the array', () => {
+      const inputArray = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+      const shuffledArray = [ ...inputArray ];
 
+      DyFM_Array.shuffle(shuffledArray);
+
+      // Check if the elements are shuffled (at least one position is different)
+      let samePositionCount = 0;
+
+      for (let i = 0; i < inputArray.length; i++) {
+        if (inputArray[i] === shuffledArray[i]) {
+          samePositionCount++;
+        }
+      }
+      expect(samePositionCount).toBeLessThan(inputArray.length);
+
+      // Check if all elements are still present after shuffle
+      expect(shuffledArray.sort()).toEqual(inputArray.sort());
+    });
+
+    it('should handle empty array', () => {
+      const inputArray: number[] = [];
+      const shuffledArray = DyFM_Array.shuffle(inputArray);
+
+      expect(shuffledArray).toEqual([]);
+    });
+  });
+  
+  describe('page function', () => {
+    const array = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
+    const pageSize = 2;
+
+    it('should return the correct page of items based on pageIndex and pageSize', () => {
+      expect(DyFM_Array.page(array, 0, pageSize)).toEqual([ 1, 2 ]);
+      expect(DyFM_Array.page(array, 1, pageSize)).toEqual([ 3, 4 ]);
+      expect(DyFM_Array.page(array, 2, pageSize)).toEqual([ 5, 6 ]);
+      expect(DyFM_Array.page(array, 3, pageSize)).toEqual([ 7, 8 ]);
+    });
+
+    it('should return an empty array if the page is out of bounds', () => {
+      expect(DyFM_Array.page(array, 4, pageSize)).toEqual([]);
+      expect(DyFM_Array.page(array, -1, pageSize)).toEqual([]);
+    });
+  });
+  
+  describe('paged function', () => {
+    it('should return a paginated array', () => {
+      const array = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
+      const pageIndex = 1;
+      const pageSize = 4;
+      const expected: DyFM_Paged<any> = {
+        pageIndex: 1,
+        pageSize: 4,
+        total: 10,
+        totalPageCount: 3,
+        items: [ 5, 6, 7, 8 ],
+      };
+      
+      const result = DyFM_Array.paged(array, pageIndex, pageSize);
+      
+      expect(result).toEqual(expected);
+    });
+    
+    it('should handle edge cases like empty array', () => {
+      const array = [];
+      const pageIndex = 1;
+      const pageSize = 5;
+      const expected: DyFM_Paged<any> = {
+        pageIndex: 1,
+        pageSize: 5,
+        total: 0,
+        totalPageCount: 0,
+        items: [],
+      };
+      
+      const result = DyFM_Array.paged(array, pageIndex, pageSize);
+      
+      expect(result).toEqual(expected);
+    });
+  });
+  
+  describe('swap function test', () => {
+    it('should swap elements in the array correctly', () => {
+      const array = [ 1, 2, 3, 4 ];
+      const indexA = 0;
+      const indexB = 2;
+      const expectedArray = [ 3, 2, 1, 4 ];
+
+      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(expectedArray);
+    });
+
+    it('should return the same array if same indexes are provided', () => {
+      const array = [ 1, 2, 3, 4 ];
+      const indexA = 0;
+      const indexB = 0;
+
+      expect(DyFM_Array.swap(array, indexA, indexB)).toEqual(array);
+    });
+
+    // Add more test cases as needed
+  });
+  
+  xdescribe('getRoundListOppositeIndex', () => {
+    it('should return the correct opposite index when roundUp is false', () => {
+      const arrayLength = 5;
+      const index = 2;
+      const expectedOppositeIndex = 4; // 2 + Math.floor(5 / 2)
+
+      expect(DyFM_Array.getRoundListOppositeIndex(arrayLength, index)).toBe(expectedOppositeIndex);
+    });
+
+    it('should return the correct opposite index when roundUp is true', () => {
+      const arrayLength = 5;
+      const index = 2;
+      const roundUp = true;
+      const expectedOppositeIndex = 5; // 2 + Math.ceil(5 / 2)
+
+      expect(DyFM_Array.getRoundListOppositeIndex(arrayLength, index, roundUp)).toBe(expectedOppositeIndex);
+    });
+
+    it('should handle cases where oppositeIndex is greater than arrayLength', () => {
+      const arrayLength = 5;
+      const index = 3;
+      const roundUp = true; // roundUp doesn't matter in this case
+      const expectedOppositeIndex = 3; // 3
+
+      expect(DyFM_Array.getRoundListOppositeIndex(arrayLength, index, roundUp)).toBe(expectedOppositeIndex);
+    });
+  });
+  
+  xdescribe('getRoundListOutboundIndex function', () => {
+    it('should return the correct element in the array', () => {
+      const array = [ 1, 2, 3, 4, 5 ];
+      
+      expect(DyFM_Array.getRoundListOutboundIndex(array, 3)).toBe(4);
+      expect(DyFM_Array.getRoundListOutboundIndex(array, 7)).toBe(3); // index wraps around
+      expect(DyFM_Array.getRoundListOutboundIndex(array, -2)).toBe(4); // negative index wraps around
+    });
+
+    it('should return null for invalid input', () => {
+      const emptyArray: number[] = [];
+      
+      expect(DyFM_Array.getRoundListOutboundIndex(emptyArray, 0)).toBe(null); // empty array
+      expect(DyFM_Array.getRoundListOutboundIndex(null, 0)).toBe(null); // null array
+    });
+  });
+
+  describe('stringListHasMultiplications', () => {
+    it('should return true if input string array contains duplicates', () => {
+      const input1 = [ 'apple', 'banana', 'apple', 'orange' ];
+
+      expect(DyFM_Array.stringListHasMultiplications(input1)).toBe(true);
+  
+      const input2 = [ 'apple', 'banana', 'orange' ];
+
+      expect(DyFM_Array.stringListHasMultiplications(input2)).toBe(false);
+    });
+  });
+
+  describe('filterStringMultiplications', () => {
+    xit('should return an array with duplicates filtered out', () => {
+      const inputList = [ 'abc', 'def', 'abc', 'ghi', 'abc' ];
+      const expectedOutput = [ 'abc' ];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it('should return an empty array if no duplicates are present', () => {
+      const inputList = [ 'abc', 'def', 'ghi' ];
+      const expectedOutput: string[] = [];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+
+    it('should handle empty input array and return empty array', () => {
+      const inputList: string[] = [];
+      const expectedOutput: string[] = [];
+
+      const result = DyFM_Array.filterStringMultiplications(inputList);
+
+      expect(result).toEqual(expectedOutput);
+    });
+  });
+
+  describe('gatherStringMultiplications', () => {
+    it('should return an array of arrays containing duplicated strings', () => {
+      const input = [ 'apple', 'banana', 'apple', 'cherry', 'banana', 'banana' ];
+      const expectedOutput = [[ 'apple', 'apple' ], [ 'banana', 'banana', 'banana' ]];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    it('should return an empty array for no duplicated strings', () => {
+      const input = [ 'apple', 'banana', 'cherry' ];
+      const expectedOutput = [];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    it('should return empty array for an empty input array', () => {
+      const input: string[] = [];
+      const expectedOutput: string[][] = [];
+
+      expect(DyFM_Array.gatherStringMultiplications(input)).toEqual(expectedOutput);
+    });
+  
+    // Add more test cases as needed
+  });
+  
+  describe('haveMultiplications', () => {
+    it('should return true if dataList contains any duplicate entry based on the given key', () => {
+      const dataList = [
+        { _id: 1, name: 'John' },
+        { _id: 2, name: 'Jane' },
+        { _id: 3, name: 'Alice' },
+        { _id: 1, name: 'Bob' },
+      ];
+
+      const result = DyFM_Array.haveMultiplications(dataList, '_id');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if dataList does not contain any duplicate entry based on the given key', () => {
+      const dataList = [
+        { _id: 1, name: 'John' },
+        { _id: 2, name: 'Jane' },
+        { _id: 3, name: 'Alice' },
+        { _id: 4, name: 'Bob' },
+      ];
+
+      const result = DyFM_Array.haveMultiplications(dataList, '_id');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('filterMultiplications', () => {
+    xit('should filter out duplicate items based on the specified key', () => {
+      const dataList = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 1, name: 'Charlie' },
+        { _id: 3, name: 'David' },
+        { _id: 1, name: 'Eve' },
+      ];
+
+      const expectedFilteredData = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 3, name: 'David' },
+      ];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual(expectedFilteredData);
+    });
+
+    it('should return an empty array if no duplicates are found', () => {
+      const dataList = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 3, name: 'Charlie' },
+      ];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual([]);
+    });
+
+    it('should handle empty input list', () => {
+      const dataList: any[] = [];
+
+      const filteredData = DyFM_Array.filterMultiplications(dataList);
+
+      expect(filteredData).toEqual([]);
+    });
+  });
+
+  describe('gatherMultiplications', () => {
+    it('should gather multiplications based on the specified key', () => {
+      const dataList = [
+        { _id: 1, name: 'Alice' },
+        { _id: 2, name: 'Bob' },
+        { _id: 1, name: 'Charlie' },
+        { _id: 3, name: 'David' },
+        { _id: 2, name: 'Eve' },
+        { _id: 3, name: 'Frank' },
+      ];
+  
+      const expectedMultiplications = [
+        [
+          { _id: 1, name: 'Alice' },
+          { _id: 1, name: 'Charlie' },
+        ],
+        [
+          { _id: 2, name: 'Bob' },
+          { _id: 2, name: 'Eve' },
+        ],
+        [
+          { _id: 3, name: 'David' },
+          { _id: 3, name: 'Frank' },
+        ],
+      ];
+  
+      expect(DyFM_Array.gatherMultiplications(dataList)).toEqual(expectedMultiplications);
+    });
+  });
 });

package/src/_collections/utils/array.util.ts

@@ -89,10 +89,10 @@ export class DyFM_Array {
     let randomIndex: number;
 
     while (0 < currentIndex) {
-      randomIndex = Math.floor(Math.random() * currentIndex);
       currentIndex--;
-
-      [ array[currentIndex], array[randomIndex] ] = [ array[randomIndex], array[currentIndex] ];
+      
+      randomIndex = Math.floor(Math.random() * (array.length - 1));
+      this.swap(array, currentIndex, randomIndex);
     }
 
     return array;

package/src/_collections/utils/math/box-bounds.spec.ts

@@ -0,0 +1,79 @@
+
+import { DyFM_BoxBounds } from './box-bounds.util';
+import { DyFM_Vector2_Util } from './vector2.util';
+
+xdescribe('DyFM_BoxBounds', () => {
+  let boxBounds: DyFM_BoxBounds;
+  const mockPosition = new DyFM_Vector2_Util({ x: 0, y: 0 });
+  const mockSize = new DyFM_Vector2_Util({ x: 10, y: 10 });
+
+  beforeEach(() => {
+    boxBounds = new DyFM_BoxBounds(mockPosition, mockSize);
+  });
+
+  it('should set position correctly ()', () => {
+    const newPosition = new DyFM_Vector2_Util({ x: 5, y: 5 });
+
+    boxBounds.pos = newPosition;
+    expect(boxBounds.pos).toEqual(newPosition);
+  });
+
+  it('should get position correctly', () => {
+    const expectedPosition = new DyFM_Vector2_Util({ x: 5, y: 5 });
+
+    expect(boxBounds.pos).toEqual(expectedPosition);
+  });
+
+  it('should set size correctly', () => {
+    const newSize = new DyFM_Vector2_Util({ x: 20, y: 20 });
+
+    boxBounds.size = newSize;
+    expect(boxBounds.size).toEqual(newSize);
+  });
+
+  it('should get size correctly', () => {
+    const expectedSize = new DyFM_Vector2_Util({ x: 20, y: 20 });
+
+    expect(boxBounds.size).toEqual(expectedSize);
+  });
+
+  it('should calculate center correctly', () => {
+    const expectedCenter = new DyFM_Vector2_Util({ x: 10, y: 10 });
+
+    boxBounds['calcCenter']();
+    expect(boxBounds.center).toEqual(expectedCenter);
+  });
+
+  it('should calculate center margin correctly', () => {
+    const expectedCenterMargin = new DyFM_Vector2_Util({ x: -5, y: -5 });
+
+    boxBounds['calcCenter']();
+    expect(boxBounds.centerMargin).toEqual(expectedCenterMargin);
+  });
+
+  it('should return true for constructed method', () => {
+    expect(boxBounds.constructed()).toBe(true);
+  });
+
+  it('should throw error when newValues has undefined position', () => {
+    expect(() => {
+      boxBounds.newValues(undefined, { x: 10, y: 10 });
+    }).toThrow(Error);
+  });
+
+  it('should throw error when newValues has undefined size', () => {
+    expect(() => {
+      boxBounds.newValues({ x: 0, y: 0 }, undefined);
+    }).toThrow(Error);
+  });
+
+  it('should clone and return a new instance', () => {
+    const clonedBoxBounds = boxBounds.clone();
+
+    expect(clonedBoxBounds).toBeInstanceOf(DyFM_BoxBounds);
+    expect(clonedBoxBounds).toEqual(boxBounds);
+  });
+
+  // Add more test cases as needed
+
+});

package/src/_collections/utils/math/box-bounds.util.ts

@@ -10,7 +10,7 @@ import { DyFM_Vector2_Util } from './vector2.util';
  * (if this is not true, report it as a bug)
  */
 export class DyFM_BoxBounds {
-  private _pos: DyFM_Vector2_Util;
+  private readonly _pos: DyFM_Vector2_Util;
   set pos(value: DyFM_Vector2) {
     this._pos.newValues(value);
 
@@ -20,7 +20,7 @@ export class DyFM_BoxBounds {
     return this._pos;
   }
 
-  private _size: DyFM_Vector2_Util;
+  private readonly _size: DyFM_Vector2_Util;
   set size(value: DyFM_Vector2) {
     this._size.newValues(value);
     

package/src/_models/control-models/data-property-params.control-model.ts

@@ -29,7 +29,7 @@ export class DyFM_DataProperty_Settings<T>{
   minlength?: number;
   maxlength?: number;
 
-  subObjectParams?: DyFM_DataProperties<T>;
+  subObjectParams?: DyFM_DataProperties<any>;
 
   additionalValidators?: ((data: any/* : T[K] */) => void)[];
 }

package/src/_models/control-models/error.control-model.ts

@@ -625,7 +625,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * a
  * @beta
  * v
@@ -633,7 +633,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * b
  * @decorator
  * v
@@ -641,7 +641,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * dc
  * @deprecated
  * v
@@ -649,7 +649,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * dp
  * @defaultValue
  * v
@@ -657,7 +657,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * dv
  * @eventProperty
  * v
@@ -665,7 +665,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * ep
  * @example
  * v
@@ -673,7 +673,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * ex
  * @experimental
  * v
@@ -681,7 +681,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * exp
  * @inheritDoc
  * v
@@ -689,7 +689,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * in
  * @internal
  * v
@@ -697,7 +697,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * int
  * @label
  * v
@@ -705,7 +705,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * lab
  * @link
  * v
@@ -713,7 +713,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * li
  * @override
  * v
@@ -721,13 +721,13 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * v
  * sadfas d
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * ov
  * @packageDocumentation
  * v
@@ -735,7 +735,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * pad
  * @param
  * v
@@ -743,7 +743,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * par
  * @privateRemarks
  * v
@@ -751,7 +751,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * pr
  * @public
  * v
@@ -759,7 +759,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * p
  * @readonly
  * v
@@ -767,7 +767,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * re
  * @remarks
  * v
@@ -775,7 +775,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * rem
  * @returns
  * v
@@ -783,7 +783,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * ret
  * @sealed
  * v
@@ -791,7 +791,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * sea
  * @see
  * v
@@ -799,7 +799,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * see
  * @throws
  * v
@@ -807,7 +807,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * th
  * @typeParam
  * v
@@ -815,7 +815,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * typ
  * @virtual
  * v
@@ -823,7 +823,7 @@ Unofficial codes
  * fs
  * daf
  * d as
- * dafs // asd sa `sadf ` sadf asd******* asdf asd f asd
+ * dafs // asd"" sa `sadf ` sadf asd******* asdf asd"" f asd
  * 
  * 
  * @see {@link http://example.com/@internal LINK}