cavalion-js 1.0.74 → 1.0.76

package/.md

@@ -1,15 +1,17 @@
-* [CHANGELOG.md]() - [README.md]() - [package.json]()
-* [.workspace](`(devtools/Workspace<${ws.getSpecializer()}>)`) - [.js]()
-
+* [CHANGELOG.md]() - [README.md]() - [package.json]() - [PROMPT.md]()
 
 # cavalion-js
 
+* [openai.com](https://chat.:)
+	* [String Word & Line Counter](https://chat.openai.com/c/01217e42-e74a-4d6a-b327-883ebfb3fa58)
+	* [Setting Up SPA Environment](https://chat.openai.com/c/2ff4e435-dd2d-46e3-a08d-58ccae92ee93)
 * [src](:/)
 	* **[console](src/:/)**
 	* **[data](src/:/)** - [design](src/:/)
 	* **[entities](src/:/)** - [entities.js](src/) - [features](src/:/)
 	* [js](src/:/) / [\_js.js](src/js/:) - [extensions.js](src/js/:) - _[global.js](src/js/:)_? - _[define.js](src/js/:)?_ 
 		- [defineClass.js](src/js/:) - [referenceClass.js](src/js/:) 
+			- **[JsObject.js](src/js/:) - [Class.js](src/js/:) **
 		- [json.js](src/:) - [locale.js](src/:) - [text.js](src/:)
 		- [script.js](src/:) - [relscript.js](src/:) 
 		- [stylesheet.js](src/:) 
@@ -47,6 +49,26 @@
 	- [Scaffold.js](src/js/:)
 	- [Type.js](src/js/:)
 
+# `2023/05/23` countWords
+
+String.prototype.countLinesAndWords = function() {
+  const lines = this.split('\n').length;
+  const words = this.split(/\s+/).length;
+  return { lines, words };
+};
+
+// Usage example:
+const text = 'Hello\nWorld!\nThis is a sample text.';
+const { lines, words } = text.countLinesAndWords();
+console.log('Number of lines:', lines);
+console.log('Number of words:', words);
+
+# `2023/05/11` Constructing...
+
+The name of the constructor for vcl/ui/Node.closeable is not correct.
+
+![20230511-091729-jjXuKW](https://raw.githubusercontent.com/relluf/screenshots/master/20230511-091729-jjXuKW.png)
+
 # `2022/11/02`
 
 What about a shared _polyfill_-like file, loaded at startup in order to fill in the gaps of packages that are not updated/compiled just yet.

package/CHANGELOG.md

@@ -1,4 +1,14 @@
-### 2023/03/30 - 1.0.74
+### 2023/09/30 - 1.0.76
+
+* Fixes a solid bug, in _JsObject.prototype.setProperties()_, sure why not?
+
+### 2023/06/30 - 1.0.75
+
+* Introduces locales.mixIn, prefixed.has()
+* Ensures that Printer.prottype.print returns the printed value 
+* Refactores String.escape to use JSON.stringify
+
+### 2023/06/30 - 1.0.74
 
 * Introduces `locale.has()`
 

package/PROMPT.md

@@ -0,0 +1,19 @@
+> _I want to document my homemade/written cavalion-js library. It deals with a JavaScript class system and some utility classes for manipulating the DOM, printing to a "in-page console". It must be using code examples a lot._
+
+"From now on, I want you to act as a technical writer and JavaScript expert focusing on library documentation.
+
+We are documenting the 'cavalion-js' library, which is a homemade JavaScript library that provides a class system and utility classes for DOM manipulation and printing to an in-page console.
+
+Start with an overview of the library, explaining its purpose, benefits, and main features. Provide a high-level view of the class system and utility classes it includes. Explain what problems this library solves and why someone might choose to use it over other solutions.
+
+Next, delve into the specifics of the JavaScript class system that 'cavalion-js' implements. Explain how to define classes, inherit from other classes, override methods, and use other features of the class system. Use code examples to illustrate these concepts.
+
+Then, document the utility classes for manipulating the DOM. Provide a comprehensive guide to each class, describing what it does and how to use it. Include code examples for each utility, showing how to perform common tasks like selecting elements, manipulating element attributes, and modifying the DOM structure.
+
+After that, cover the in-page console feature. Explain how it works, how to print messages to it, and any customization options it provides. Again, use code examples to clearly demonstrate its usage.
+
+Also, provide a section on installation and setup instructions for the library, and any other important details like browser compatibility or known issues.
+
+Ensure that the documentation is clear, thorough, and easy to follow. Use a lot of code examples to illustrate how to use the various features of 'cavalion-js.' Provide enough detail so that both novice and experienced JavaScript developers can effectively use the library in their projects.
+
+Throughout this process, use the best practices for writing technical documentation, such as clear language, logical organization, and regular updates as the library evolves."

package/Resource-o4rk6z5bml.md

@@ -0,0 +1,69 @@
+# JavaScript Classes: The Complete Guide To Creating Your Own Custom Class System
+
+JavaScript is a powerful programming language that allows you to create custom code that works in the browser. If you want to create your own custom class system, then this article is for you. It will teach you how to define classes in JavaScript and turn them into something that can be used anywhere on your website.
+
+## The Basics of JavaScript Classes
+
+In JavaScript, a class is just a special type of function. Classes are in fact "special functions", and just like you can define function expressions and function declarations, the same goes for classes.
+There are two ways to create a class in JavaScript:
+
+The first way is to use a class declaration. To do this, you use the class keyword followed by the name of the class. For example:
+
+	class Rectangle {
+	   // ...
+	}
+
+This creates a new class called Rectangle. You can then add properties and methods to this class by using the prototype property of the Rectangle class:
+
+	Rectangle.prototype.width = 10;
+	Rectangle.prototype.height = 5;
+
+You can also add methods to the prototype:
+
+	Rectangle.prototype.getArea = function() {
+	   return this.width * this.height;
+	}
+
+## Defining a Class System in JavaScript
+
+In JavaScript, a class is a blueprint for an object. It is a template that you can use to create new objects with the same characteristics. A class system is a way of organizing and defining classes so that they can be easily reused and extended.
+
+There are several ways to define a class system in JavaScript. The most common way is to use the prototype-based approach. This approach uses the prototype property of objects to create new classes. The prototype property is an object that contains the properties and methods that will be inherited by all instances of the class.
+
+Another way to define a class system in JavaScript is to use the constructor function. This function allows you to create objects with the same characteristics as the constructor function's prototype object. The constructor function is used to initialize the new object's properties and methods.
+
+Once you have defined your class system, you can use it to create new objects. To do this, you first need to create a constructor function for your class. This function will take any arguments that you want to pass into your new object. Once you have created your constructor function, you can then use the new keyword to create an instance of your class.
+
+## Step by Step Creation of a Class Definition
+
+Assuming you have a basic understanding of Object-Oriented Programming concepts, creating a class in JavaScript is very simple. In fact, there are only a few steps involved:
+
+* 1) First, create a function that will serve as the class constructor. This function should accept any parameters that you wish to pass into the class instance when it is created.
+
+* 2) Next, create any properties or methods that you wish to add to the class. These can be defined directly within the constructor function, or they can be added after the fact using the prototype object.
+
+* 3) Finally, return the newly created class from the constructor function.
+
+That's all there is to it! With these three steps, you can create your own custom classes in JavaScript.
+
+## Using the New Class in JS
+
+Assuming you have a basic understanding of JavaScript classes, let's explore how to use the new class in JS.
+
+As we discussed earlier, the new keyword is used to create an instance of a class. When creating an instance of a class, you must provide the arguments that will be passed to the class constructor function. For example:
+
+	class MyClass {
+	  constructor(arg1, arg2) {
+	    this.arg1 = arg1;
+	    this.arg2 = arg2;
+	  }
+	  myMethod() {
+	    // do something with this.arg1 and this.arg2 here
+	  }
+	}
+
+	const myInstance = new MyClass('foo', 'bar');
+
+## Conclusion
+
+In conclusion, JavaScript classes provide a great way to create your own custom class system. With the help of this guide, you should now be able to create your own custom classes and use them in your web development projects. If you have any questions or if there is anything we missed, please feel free to reach out and let us know. We would be more than happy to help you out.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cavalion-js",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "Cavalion common JavaScript library",
   "main": "index.js",
   "scripts": {

package/src/console/Printer.js

@@ -70,7 +70,6 @@ define(function(require) {
 	});
 
 	var Printer = {
-
 		prototype: {
 			_node: null,
 
@@ -105,6 +104,8 @@ define(function(require) {
 				}
 				this._node.appendChild(line.getNode());
 				this._node.scrollTop = this._node.scrollHeight;
+				
+				return arguments.length > 1 ? arguments[1] : arguments[0];
 			}
 		}
 	};

package/src/js/JsObject.js

@@ -16,9 +16,7 @@ define(function(require) {
 	var JsObject = Class.define;
 
 	return (JsObject = JsObject(require, {
-
 		inherits: Object,
-
 		prototype: {
 
 			'@hashCode': null,
@@ -77,14 +75,13 @@ define(function(require) {
 			    var props = this.defineProperties();
 			    for(var k in values) {
 			        var prop = props[k];
-			        if(k) {
+			        if(prop) {
 			            prop.set(this, values[k]);
 			        }
 			    }
 			    return this;
 			}
 		},
-
 		statics: {
 
 			$: references,

package/src/js.js

@@ -25,7 +25,7 @@ define(function(require) {
 			} catch(e) {
 				return e;
 			}
-		}
+		}		
 	});
 
 });

package/src/locale.js

@@ -245,6 +245,11 @@ define(function(require) {
         		onLoad(dict);
         	});
         },
+        mixIn: function(dict) {
+        	const dest = locale[locale.loc], proto = {};	
+    		dict = unwrap(js.mi(js.obj2kvp(proto), js.obj2kvp(dict)));
+    		js.mi(dest, dict);
+        },
         define: locale.define
 	};
 });