Updated dependency @writetome51/public-array-content to version ~1.2.0.

The .copy property has been moved to PublicArrayContent.
Added comments to lib/index.ts.
Minor update to README.

Author: Steve Thompson

README.md

@@ -51,7 +51,7 @@ new PublicArray(array = [])
 ###### This is the array to be operated on.
 
 #### copy: PublicArray (read-only)  
-###### an independent copy of the PublicArray instance
+######  a copy of the PublicArray instance, containing an independent copy of this.data that can be manipulated separately.
 
 #### length: number (read-writable) 
 ###### length of this.data
@@ -545,7 +545,7 @@ forEach(iterationFunction): this
     // Behaves same as Array.forEach()
     // iterationFunction = function(currentValue, currentIndex?, entireArray?){...}
     
-set(newArray): this
+set(newArray): void
     // Changes value of this.data to newArray without breaking its memory reference.
     // So if there are copies of this.data, the copies will be updated as well.
 
@@ -609,9 +609,6 @@ performance boost if you just instantiate PublicArrayReplacer instead of PublicA
 let replace = new PublicArrayReplacer(array);
 replace.adjacentAt(2, ['just', 'an', 'example']);
 ```
-## Inheritance Chain
-
-PublicArray<-PublicArrayContent<-PublicArrayContainer<-BatchGetterSetter<-MethodChainable<-SelfIdentifiable
 
 
 ## License

dist/index.d.ts

@@ -8,51 +8,45 @@ import { PublicArrayContent } from '@writetome51/public-array-content';
  The main reason you would use this class is if you hate JavaScript's built-in Array
  methods, like .slice(), .splice(), .push(), and .shift().  This class has much clearer
  and expressive method names, and a lot more of them.
-
- A few examples of usage:
-
- let arr = getPublicArray([1,2,3,4,5,6]);
- arr.remove.tail(2); // arr.data is now [1,2,3,4]
- if (arr.notEmpty) arr.prepend([10]); // arr.data is now [10,1,2,3,4]
  **********************/
 
 export declare class PublicArray extends PublicArrayContent {
 
+	readonly filter: any;
+	readonly getConverted: any;
+	readonly get: any;
+	readonly getAndRemove: any;
+	readonly insert: any;
+	readonly remove: any;
+	readonly replace: any;
+	readonly sort: any;
 
-	readonly copy: PublicArray; // (an independent copy of this instance).
-	readonly filter; // PublicArrayFilter
-	readonly getConverted; // PublicArrayGetterConverter;
-	readonly get; // PublicArrayGetter;
-	readonly getAndRemove; // PublicArrayGetterRemover;
-	readonly insert; // PublicArrayInserter;
-	readonly remove; // PublicArrayRemover;
-	readonly replace; // PublicArrayReplacer;
-	readonly sort; // PublicArraySorter;
-
+	private _filter;
+	private _getConverted;
+	private _get;
+	private _getAndRemove;
+	private _insert;
+	private _remove;
+	private _replace;
+	private _sort;
 
-	private _filter; // PublicArrayFilter
-	private _getConverted; // PublicArrayGetterConverter
-	private _get; // PublicArrayGetter;
-	private _getAndRemove; // PublicArrayGetterRemover;
-	private _insert; // PublicArrayInserter;
-	private _remove; // PublicArrayRemover;
-	private _replace; // PublicArrayReplacer;
-	private _sort; // PublicArraySorter;
+	private __dependencyClasses;
 
 
 	constructor(data?: any[]);
 
 
+	set(newArray: any[]): void;
+
+
 	append(values: any[]): this;
 
 
 	prepend(values: any[]): this;
 
 
-	forEach(
-		iterationFunction: (currentValue: any, currentIndex?: number, entireArray?: any[]) => any
-	): this;
+	forEach(iterationFunction: (currentValue: any, currentIndex?: number, entireArray?: any[]) => any): this;
 
 
-	set(newArray: any[]): this;
+	private __getInstancePropertyGetter;
 }

dist/index.js

@@ -24,19 +24,15 @@ var public_array_content_1 = require("@writetome51/public-array-content");
  The main reason you would use this class is if you hate JavaScript's built-in Array
  methods, like .slice(), .splice(), .push(), and .shift().  This class has much clearer
  and expressive method names, and a lot more of them.
-
- A few examples of usage:
-
- let arr = getPublicArray([1,2,3,4,5,6]);
- arr.remove.tail(2); // arr.data is now [1,2,3,4]
- if (arr.notEmpty) arr.prepend([10]); // arr.data is now [10,1,2,3,4]
  **********************/
 var PublicArray = /** @class */ (function (_super) {
     __extends(PublicArray, _super);
     function PublicArray(data // the actual array, represented by inherited property this.data
     ) {
         if (data === void 0) { data = []; }
         var _this = _super.call(this, data) || this;
+        // These are not loaded at the top with import statements because we're loading them
+        // lazily in the getter functions to boost performance.
         var dependencyClasses = [
             { path: '@writetome51/public-array-filter', name: 'PublicArrayFilter' },
             { path: '@writetome51/public-array-getter-converter', name: 'PublicArrayGetterConverter' },
@@ -49,11 +45,10 @@ var PublicArray = /** @class */ (function (_super) {
         ];
         _this._createGetterAndOrSetterForEach(
         // each of these is a public property:
-        ['filter', 'getConverted', 'get', 'getAndRemove', 'insert',
-            'remove', 'replace', 'sort'], {
+        ['filter', 'getConverted', 'get', 'getAndRemove', 'insert', 'remove', 'replace', 'sort'], {
             get_getterFunction: function (property, index) {
                 return function () {
-                    // Lazy-Loading is used to instantiate these properties:
+                    // Lazy-Loading is used to instantiate each property:
                     if (!(_this["_" + property])) { // if property not set...
                         var dependencyClass = dependencyClasses[index];
                         // @ts-ignore
@@ -67,15 +62,10 @@ var PublicArray = /** @class */ (function (_super) {
         });
         return _this;
     }
-    Object.defineProperty(PublicArray.prototype, "copy", {
-        // this.copy  -- returns independent copy of 'this', not linked to 'this' in any way.
-        get: function () {
-            // @ts-ignore
-            return di_factory_1.DIFactory.getInstance(PublicArray, [this.get.copy()]);
-        },
-        enumerable: true,
-        configurable: true
-    });
+    // changes the value of this.data without breaking its memory reference.
+    PublicArray.prototype.set = function (newArray) {
+        set_array_1.setArray(this.data, newArray);
+    };
     PublicArray.prototype.append = function (values) {
         return this.returnThis_after(array_append_prepend_1.append(values, this.data));
     };
@@ -85,10 +75,6 @@ var PublicArray = /** @class */ (function (_super) {
     PublicArray.prototype.forEach = function (iterationFunction) {
         return this.returnThis_after(this.data.forEach(iterationFunction));
     };
-    // Use this to change the value of this.data without breaking its memory reference.
-    PublicArray.prototype.set = function (newArray) {
-        return this.returnThis_after(set_array_1.setArray(this.data, newArray));
-    };
     return PublicArray;
 }(public_array_content_1.PublicArrayContent));
 exports.PublicArray = PublicArray;

dist/tests.d.ts

@@ -0,0 +1 @@
+export {};

lib/index.ts

@@ -11,19 +11,14 @@ import { PublicArrayContent } from '@writetome51/public-array-content';
  The main reason you would use this class is if you hate JavaScript's built-in Array
  methods, like .slice(), .splice(), .push(), and .shift().  This class has much clearer
  and expressive method names, and a lot more of them.
-
- A few examples of usage:
-
- let arr = getPublicArray([1,2,3,4,5,6]);
- arr.remove.tail(2); // arr.data is now [1,2,3,4]
- if (arr.notEmpty) arr.prepend([10]); // arr.data is now [10,1,2,3,4]
  **********************/
 
 
 export class PublicArray extends PublicArrayContent {
 
 
-	// readonly  copy: PublicArray (an independent copy of this instance).
+	// These are all created with getter functions in the constructor.
+
 	readonly filter; // PublicArrayFilter
 	readonly getConverted; // PublicArrayGetterConverter;
 	readonly get; // PublicArrayGetter;
@@ -34,6 +29,8 @@ export class PublicArray extends PublicArrayContent {
 	readonly sort; // PublicArraySorter;
 
 
+	// These are all instances gotten from dependencyClasses in the constructor.
+
 	private _filter; // PublicArrayFilter
 	private _getConverted; // PublicArrayGetterConverter
 	private _get; // PublicArrayGetter
@@ -50,6 +47,8 @@ export class PublicArray extends PublicArrayContent {
 
 		super(data);
 
+		// These are not loaded at the top with import statements because we're loading them
+		// lazily in the getter functions to boost performance.
 		let dependencyClasses = [
 			{path: '@writetome51/public-array-filter', name: 'PublicArrayFilter'},
 			{path: '@writetome51/public-array-getter-converter', name: 'PublicArrayGetterConverter'},
@@ -63,12 +62,13 @@ export class PublicArray extends PublicArrayContent {
 
 		this._createGetterAndOrSetterForEach(
 			// each of these is a public property:
-			['filter', 'getConverted', 'get', 'getAndRemove', 'insert',
-				'remove', 'replace', 'sort'],
+			['filter', 'getConverted', 'get', 'getAndRemove', 'insert', 'remove', 'replace', 'sort'],
+
 			{
 				get_getterFunction: (property, index) => {
 					return () => {
-						// Lazy-Loading is used to instantiate these properties:
+
+						// Lazy-Loading is used to instantiate each property:
 						if (!(this[`_${property}`])) { // if property not set...
 							let dependencyClass = dependencyClasses[index];
 							// @ts-ignore
@@ -84,10 +84,10 @@ export class PublicArray extends PublicArrayContent {
 	}
 
 
-	// this.copy  -- returns independent copy of 'this', not linked to 'this' in any way.
-	get copy(): PublicArray {
-		// @ts-ignore
-		return DIFactory.getInstance(PublicArray, [this.get.copy()]);
+	// changes the value of this.data without breaking its memory reference.
+
+	set(newArray): void {
+		setArray(this.data, newArray);
 	}
 
 
@@ -106,10 +106,4 @@ export class PublicArray extends PublicArrayContent {
 	}
 
 
-	// Use this to change the value of this.data without breaking its memory reference.
-	set(newArray): this {
-		return this.returnThis_after(setArray(this.data, newArray));
-	}
-
-
 }

package-lock.json

@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@writetome51/public-array-remover": "~1.0.1",
-    "@writetome51/public-array-content": "~1.0.4",
+    "@writetome51/public-array-content": "~1.2.0",
     "@writetome51/public-array-getter": "~1.0.1",
     "@writetome51/public-array-inserter": "~2.0.0",
     "@writetome51/public-array-sorter": "~1.0.0",
@@ -41,6 +41,6 @@
     "@writetome51/public-array-filter": "~1.0.5",
     "@writetome51/array-append-prepend": "~1.0.3",
     "@writetome51/di-factory": "~1.0.0",
-    "@writetome51/set-array": "~1.0.0"
+    "@writetome51/set-array": "~1.0.1"
   }
 }