curent javadoc and jsdoc

Author: dazoulay-simplicite

content/CTG_40_platform/CTG_50_userinterface/CTG_30_externalobjects/LSN_10_basic/basic.md

@@ -4,9 +4,9 @@
 
 It is an object that allows for customized interactions and behaviors within Simplicité. They are objects that you will implement to serve specific needs.
 
-In such objects you will be able to interact with Simplicité by using the [Ajax Library](https://platform.simplicite.io/6.2/jsdoc/index.html) to properly interact with the native part of your solution.
+In such objects you will be able to interact with Simplicité by using the [Ajax Library](https://platform.simplicite.io/current/jsdoc/index.html) to properly interact with the native part of your solution.
 
-There are several types of *External Objects*, that all serve a certain use-case of type of need:  
+There are several types of *External Objects*, that all serve a certain use-case of type of need:
 - Basic
 - [UI page or component](/lesson/docs/platform/userinterface/externalobjects/uicomponent)
 - [Web-page](/lesson/docs/platform/userinterface/externalobjects/webpage)
@@ -30,7 +30,7 @@ The most used are:
 All **External Objects** are organized as web elements, thus are composed of 3 [resources](/lesson/docs/platform/userinterface/resources):
 - **HTML** is the resource containing the *html* code of your object that defines its core structure and organization.
 - **STYLES** is the resource containing the stylesheet (*css* or *less*) associated with your object's HTML.
-- **CLASS** is the resource with the javascript file inside of which you will code the behaviors and interactions for your External Object. 
+- **CLASS** is the resource with the javascript file inside of which you will code the behaviors and interactions for your External Object.
 
 And in addition, all external objects works with a **Java Class** that ensures both their proper setup, and the rendering of the web resources.
 
@@ -56,14 +56,14 @@ The **Basic** nature refers directly to the mother class `com.simplicite.util.Ex
     - **Nature** shall be **Basic**.
     - **Module Name** for the module containing your external object.
     - **UI Widget** to **Yes** if your object can be added to a [dashboard](/lesson/docs/platform/userinterface/views/dashboard) and **No** otherwise.
-    > Example values:  
+    > Example values:
     > <img src="basic_extobj_fields.png" alt="fields values" width="65%">
 4. Click **Save**.
-5. Click **Create Resources** to create the web-resources (html|css|js) for your object.  
+5. Click **Create Resources** to create the web-resources (html|css|js) for your object.
 <img src="basic_resources.png" alt="web resources" width="65%">
 
 6. (optional) Click **Edit Code** to generate the custom java class for your object.
-    <details>  
+    <details>
     <summary>Default java code</summary>
 
     ```java
@@ -101,13 +101,13 @@ The **Basic** nature refers directly to the mother class `com.simplicite.util.Ex
         }
     }
     ```
-    </details>  
-  
+    </details>
+
 7. Click **Save** and your object is ready to be implemented.
 
 ## Configuration
 
-| Field | Description | 
+| Field | Description |
 | ----- | ----------- |
 | Code | External Object's unique identifier |
 | Nature | Type of the External Object, here **UI page or component** |

content/CTG_40_platform/CTG_50_userinterface/CTG_30_externalobjects/LSN_20_uicomponent/uicomponent.md

@@ -337,7 +337,7 @@ There are several keypoints to understand and keep in mind while developing in t
 
 ### JS behavior
 
-In the **CLASS** resource, you will write the JS script for your component's behavior. Here you will have the possibility to use both the [JSDoc](https://platform.simplicite.io/6.2/jsdoc/) for frontend operations direclty in the **CLASS** resource's script, and to make few calls to the *Java* code of your component to add custom server-side operations.
+In the **CLASS** resource, you will write the JS script for your component's behavior. Here you will have the possibility to use both the [JSDoc](https://platform.simplicite.io/current/jsdoc/) for frontend operations direclty in the **CLASS** resource's script, and to make few calls to the *Java* code of your component to add custom server-side operations.
 
 > By default the only call from **CLASS** to **Java** is through `render()` that allows for your component's correct display and instantiation. But later on we'll see another method that allow for more custom calls: `service()`.
 
@@ -352,7 +352,7 @@ Simplicite.UI.ExternalObjects.TestWebPage = class extends Simplicite.UI.External
 
 The key concepts and understanding that you need are:
 - Every instantiation has to be within the ```async render(){ ... }```
-- You can work with Simplicité's API and core library using several entry points such as `$ui`, `$app` or `$grant` (documented in the [Ajax library](https://platform.simplicite.io/6.2/jsdoc/global.html)).
+- You can work with Simplicité's API and core library using several entry points such as `$ui`, `$app` or `$grant` (documented in the [Ajax library](https://platform.simplicite.io/current/jsdoc/global.html)).
 - You can manipulate most of the *BusinessObjects* and elements through the `BusinessObject.search( function() {...} )` method.
 
 You may need to implement some behaviors and features specifically on the *server-side* (though in the java code). Such workflow is required when you don't want to share informations with the front (public) or you just want the calculations to be done by the backend.

content/CTG_40_platform/CTG_50_userinterface/CTG_30_externalobjects/LSN_50_staticsite/staticsite.md

@@ -30,7 +30,7 @@ The creation process is similar to the one for any *External Object*:
 
 ## Usage
 
-As a *Static Web Page* isn't interacting with Simplicité's API or backend, you only have the 3 resources to worry about. For the development specific to Simplicité refer to the [JSdoc](https://platform.simplicite.io/6.2/jsdoc/global.html).
+As a *Static Web Page* isn't interacting with Simplicité's API or backend, you only have the 3 resources to worry about. For the development specific to Simplicité refer to the [JSdoc](https://platform.simplicite.io/current/jsdoc/global.html).
 
 > Specific use case and code examples can be found in the following lessons: [WebPage](/lesson/docs/platform/userinterface/externalobjects/webpage), [UI Component](/lesson/docs/platform/userinterface/externalobjects/uicomponent), [External Objects](/lesson/docs/platform/userinterface/externalobjects/basic).
 
@@ -76,5 +76,5 @@ Simplicite.UI.ExternalObjects.TrnStaticPage = class extends Simplicite.UI.Extern
 
 ## Read More
 
-- [JSDoc](https://platform.simplicite.io/6.2/jsdoc/global.html)
+- [JSDoc](https://platform.simplicite.io/current/jsdoc/global.html)
 - [StaticSiteExternalObject](https://platform.simplicite.io/current/javadoc/com/simplicite/webapp/web/StaticSiteExternalObject.html) (javadoc)

content/CTG_50_docs/CTG_25_front/LSN_30_javascript-dev/javascript-dev.md

@@ -78,9 +78,9 @@ try
 catch (err) console.error(err.message);
 ```
 
-The rest of this example is focusing on a Native based web-page using basic web technologies: **HTML**, **CSS**, **JS**. 
+The rest of this example is focusing on a Native based web-page using basic web technologies: **HTML**, **CSS**, **JS**.
 
-### Basic Setup 
+### Basic Setup
 
 The first step to create your custom front with the NPM Simplicite library is the same as for most of other **Node.js** projects:
 
@@ -92,19 +92,19 @@ The first step to create your custom front with the NPM Simplicite library is th
 
 Once the basic setup for your Simplicité-powered project is installed, the next step is to *structure it* like any standard web project using **Node.js**. This typically results in the following file structure:
 
-CustomNativeFront/  
-    public/  
-        style.css  
-    views/  
-        index.html  
-    app.js  
-    package.json  
-  
+CustomNativeFront/
+    public/
+        style.css
+    views/
+        index.html
+    app.js
+    package.json
+
 
 - Place all *dynamically accessed* resources, such as stylesheets and scripts for specific pages, in the **public** folder (for now, this may only include `index.html`).
 - Store all your `.html` files representing *individual pages* in the **views** folder.
 - Your main javascript code (for project's setting up at least) will be written in the `app.js` file.
-  
+
 > ***Note:*** Properly setting up and understanding why your project directory is organized this way is important to later properly implement your javascript code and ensure consistency throughout your project if you want to scale it.
 
 ### Javascript Code
@@ -170,7 +170,7 @@ const app = simplicite.session({
 - `url` defines the url for your Simplicité session, for most of the demos we use `https://demo.dev2.simplicite.io`.
 - `username` sets the username to access the session, ensure this is a valid one.
 - `password` sets the password to access the session, ensure it's the good one for your user and session.
-- `debug` defines if yes or not your session is used in debug mode. 
+- `debug` defines if yes or not your session is used in debug mode.
 </details>
 
 In the code, you’ll notice that your information can either be hardcoded with *string* values or secured by referencing a `.env` file created in your root directory. For this use case, the `.env` file might look like this:
@@ -213,7 +213,7 @@ server.use(express.static(dir + '/public'));
 <summary>Code Details</summary>
 
 - `serverHost` and `serverPort` are instanciated either from your **.env** file, **command line arguments**, or **hardcoded values**, and defines the host *IP address* and *Port* where your app should run.
-- `const server = express()` creates an express application instance, that will handle incoming HTTP requests and also manage routes & responses. 
+- `const server = express()` creates an express application instance, that will handle incoming HTTP requests and also manage routes & responses.
 - `server.disable('x-powered-by');` disables the specified header in HTTP responses, included for security reasons as it prevents revealing that app is runing on express (supposed to make it less vulnerable).
 - `const dir` stores the directory path for current module/file, converting the `import.meta.url` into a regular file path with `fileURLToPath()`, and extracting the directory part for this part using `dirname()`. It ensures the proper referencing of files relative to current **app.js** script.
 - `server.use()` serves static files from `/public` directory, and can be accessed by visiting `/filename` in browser. It enables frontend assets (images, stylesheets, additional scripts, ...).
@@ -370,12 +370,12 @@ The Simplicité JavaScript API repositories provide a wealth of examples and dem
 
 # Core Javascript usages
 
-**JavaScript development** in Simplicité plays a critical role in extending and customizing front-end functionalities. While Simplicité's core architecture is mainly *Java-based*, JavaScript is most frequently encountered in specific contexts, particularly in *External Objects* and *front-end development* scenarios. These use cases arise when there is a need to create specific, client-side behaviors or *integrate external components* into the Simplicité platform.  
+**JavaScript development** in Simplicité plays a critical role in extending and customizing front-end functionalities. While Simplicité's core architecture is mainly *Java-based*, JavaScript is most frequently encountered in specific contexts, particularly in *External Objects* and *front-end development* scenarios. These use cases arise when there is a need to create specific, client-side behaviors or *integrate external components* into the Simplicité platform.
 
-The *recurring use* of JavaScript in these contexts stems from its ability to:  
-  - Enhance user interaction with *responsive* front-end elements.  
-  - Provide flexibility in implementing custom *business logic* at the client level.  
-  - Seamlessly integrate *external libraries* or *APIs* that complement Simplicité’s core functionalities.  
+The *recurring use* of JavaScript in these contexts stems from its ability to:
+  - Enhance user interaction with *responsive* front-end elements.
+  - Provide flexibility in implementing custom *business logic* at the client level.
+  - Seamlessly integrate *external libraries* or *APIs* that complement Simplicité’s core functionalities.
 
 By focusing on these key contexts, JavaScript development within Simplicité complements its Java-based backend, enabling a richer, more adaptable, and interactive front-end experience. Whether building custom components, enhancing default UI behaviors, or connecting external systems, JavaScript is an indispensable tool for unlocking the full potential of the Simplicité platform.
 
@@ -388,7 +388,7 @@ The main utility for javascript development within Simplicité is the implementa
 The javascript development will happen within the *SCRIPT* resource of your *External Object*, and will allow you to do two things:
 
 1) **Customized behaviors:** first, you are gonna be able to apply custom behaviors and interactions for your custom object
-2) **Communicate with Simplicité:** then, you will be able to make your widget even more interactive by allowing it to discuss in various ways 
+2) **Communicate with Simplicité:** then, you will be able to make your widget even more interactive by allowing it to discuss in various ways
 
 In this case, you can declare all your javascript code within the *SCRIPT* resource, make sure that you respect common rules and methodologies, so define your methods thoughfully, don't make redundant code, don't hesitate to document your code and make reusable functions in case you need it.
 
@@ -497,7 +497,7 @@ public class MyExternalObject extends ExternalObject {
 
 			// Bootstrap page
 			BootstrapWebPage wp = new BootstrapWebPage(params.getRoot(), getDisplay());
-			
+
 			wp.appendAjax();
 			wp.appendJSInclude(HTMLTool.getResourceJSURL(this, "CLASS"));
 			wp.appendCSSInclude(HTMLTool.getResourceCSSURL(this, "STYLES"));
@@ -537,9 +537,9 @@ var MyExternalObject = (function($) {
 ```
 
 ***Code Overview:***
-- `var MyExternalPage = ...`, here the code is encapsulatied within a local variable in order to avoid polluting the global namespace.
+- `var MyExternalPage = ...`, here the code is encapsulated within a local variable in order to avoid polluting the global namespace.
 - `(function($) {...})(jQuery)` defines an immediately-invoked function expression receiving `jQuery` as an argument.
-- `new Simplicite.Ajax()` declares a new instance for the Simplicité session, with parameters `approot = ""` and `gateway = "uipublic"`. To make sure you are applying the right parameters, refer to [this part](https://platform.simplicite.io/6.1/jsdoc/Simplicite.Ajax.html) of the documentation.
+- `new Simplicite.Ajax()` declares a new instance for the Simplicité session, with parameters `approot = ""` and `gateway = "uipublic"`. To make sure you are applying the right parameters, refer to [this part](https://platform.simplicite.io/current/jsdoc/Simplicite.Ajax.html) of the documentation.
 - `function render(params) {...}` is the method called in the **Java code** to be executed when DOM is fully loaded (by `setReady()` method).
 
 To keep on going with your javascript development with this setup, you just have to declare your functions in the encapsulated function, and make sure to call the functions using the correct namespace in your `.html` resource file. In our case if you declare a *sayHello* function in yoir javascript code, then you must call `MyExternalPage.sayHello` inside of your html file.