@cyklang/cli 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.4.0",
+   "version": "0.5.1",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,13 +17,14 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.0",
+      "@cyklang/core": "^0.5.2",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",
       "inquirer": "^8.2.5",
       "loglevel": "^1.8.0",
       "mime-types": "^2.1.35",
+      "open": "^9.1.0",
       "pako": "^2.0.4"
    },
    "devDependencies": {
@@ -32,8 +33,8 @@
       "@types/pako": "^2.0.0",
       "@types/sax": "^1.2.4",
       "nodemon": "^2.0.16",
-      "ts-node": "^10.7.0",
-      "typescript": "4.5.2"
+      "ts-node": "^10.9.1",
+      "typescript": "^5.2.2"
    },
    "bin": {
       "cyk": "build/index.js"

package/src/AssetCommand.ts

@@ -7,12 +7,44 @@ import path from "path"
 import mime from 'mime-types'
 import inquirer from 'inquirer'
 // import readline from 'readline'
-import { DBAsset, DBExecuteRequest, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
+import { DBAsset, DBExecuteRequest, DBManager, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
 import FormData from 'form-data'
 
 const logger = getLogger('AssetCommand.ts')
 logger.setLevel('debug')
 
+
+//----------------------------------------------------------------------------------------------
+// scanAssets
+//----------------------------------------------------------------------------------------------
+
+const scanAssets = async (dbManager: DBManager | undefined, dest?: string): Promise<FileDescriptor[]> => {
+
+    const result: FileDescriptor[] = []
+    if (dbManager === undefined) throw 'dbManager undefined'
+    const dbReq = new DBExecuteRequest()
+    dbReq.selectFromTable = 'cyk_asset'
+    const pFields = dbReq.parameters.addVariable('fields', dbManager.scope.structure.stringDataType)
+    pFields.data = new PrimitiveData(dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype")
+    const xmlResult = await dbManager.dbExecute(dbReq)
+    if (xmlResult === undefined || xmlResult === null) throw 'xmlResult null or undefined'
+    const tag = parseXML('scanAssets', xmlResult)
+    const objResult = await dbManager.scope.structure.objectDataType.parseData(tag, dbManager.scope) as ObjectData
+    const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
+    for (let ind = 0; ind < rows.list.length; ind++) {
+        const { variable: row } = rows.list[ind]
+        const record = row.data as ObjectData
+        const asset_id = (record.variables.getData('asset_id') as PrimitiveData).value as number
+        const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
+        const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData)?.value as Date
+        // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
+
+        if (!dest || asset_route.startsWith(dest))
+            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id })
+    }
+    return result
+}
+
 export class AssetCommand extends Command {
     constructor(name: string, description: string) {
         super(name)
@@ -22,9 +54,92 @@ export class AssetCommand extends Command {
         this.addCommand(new AssetU('upload', 'upload asset content from source files to a <destination> path'))
         this.addCommand(new AssetU('update', 'update properties of asset identified by its <id>'))
         this.addCommand(new AssetU('u', '(u)pload assets content from sources or (u)pdate asset properties'))
+        this.addCommand(new AssetDelete('delete', 'delete an asset'))
     }
 }
 
+/**
+ * class AssetDelete
+ */
+class AssetDelete extends Cmd {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-i --id <id_pathname>', 'asset id or pathname to delete')
+            .option('-d --dest <destination>', 'delete all assets whose pathname begins with dest')
+            .action(async (options: any) => {
+                if (options.id)
+                    await this.commandDeleteOne(options)
+                else if (options.dest) {
+                    await this.commandDeletePathname(options)
+                }
+                else {
+                    logger.error('one of --id or --dest options is required')
+                }
+            })
+    }
+
+    /**
+     * 
+     * @param options 
+     */
+    async commandDeleteOne(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (options.id === undefined) throw '<id_or_pathname> of asset to delete is missing'
+
+            if (!options.id.startsWith('/')) throw '-i --id only pathname is supported at the moment'
+
+            const dbAsset = await this.dbManager.dbAssetExist(options.id)
+            if (dbAsset === undefined) throw 'Asset ' + options.id + ' not found'
+
+            await this.dbManager.dbAssetDelete(dbAsset)
+
+            logger.info('asset ' + dbAsset.id + ' ' + dbAsset.route + ' deleted')
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * 
+     * @param options 
+     */
+    async commandDeletePathname(options: any) {
+
+        try {
+            await this.prologue(options)
+            if (! this.dbManager) throw 'dbManager undefined'
+            const dbClient = new DBClient(this.dbManager)
+            const list = await dbClient.selectFromTable('Assets to delete', 'cyk_asset',
+                {
+                    fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1',
+                    where: (options.dest ? "asset_route like '" + options.dest + "%'" : undefined)
+                }
+
+            );
+            const reply = await inquirer.prompt({type: 'confirm', name: 'confirm', message: 'Do you want to delete these ' + list.length +  ' file(s)'})
+            if (reply.confirm) {
+                for(let ind = 0; ind < list.length; ind++) {
+                    const asset = list[ind]
+                    logger.info('delete ' + asset.asset_route)
+                    const url = '/api/admin/assets/' + asset.asset_id
+                    await this.dbRemote?.apiServer.delete(url)
+                }
+            }
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+
+    }
+
+}
+
 class AssetList extends Cmd {
     constructor(name: string, description: string) {
         super(name)
@@ -66,7 +181,7 @@ class AssetU extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-            .option('-i --id <id>', 'asset id to update properties')
+            .option('-i --id <id>', 'asset id or pathname whose properties are updated')
             .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
             .option('--access <access>', 'access rights required')
             .option('-d --dest <destination>', 'destination path, directory name')
@@ -97,12 +212,12 @@ class AssetU extends Cmd {
     async commandU(sources: string[], options: any) {
         if (sources.length > 0) {
             // upload
-            logger.debug('upload sources :', sources)
+            // logger.debug('upload sources :', sources)
             await this.commandUpload(sources, options)
         }
         else {
             // update
-            logger.debug('update', options)
+            // logger.debug('update', options)
             await this.commandUpdate(options)
         }
     }
@@ -116,12 +231,14 @@ class AssetU extends Cmd {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'
 
-            if (options.id === undefined) throw '<id_or_route> of asset to update is missing'
+            if (options.id === undefined) throw '<id_or_pathname> of asset to update is missing'
+
+            if (!options.id.startsWith('/')) throw '-i --id only pathname is supported at the moment'
 
             const dbAsset = await this.dbManager.dbAssetExist(options.id)
             if (dbAsset === undefined) throw 'Asset ' + options.id + ' not found'
 
-            await this.updateAuthAccess('cyk_asset', 'assert', dbAsset.id || '', options)
+            await this.updateAuthAccess('cyk_asset', 'asset', dbAsset.id || '', options)
 
         }
         catch (err) {
@@ -145,8 +262,8 @@ class AssetU extends Cmd {
             if (options.auth && ' basic | token | cookie | any | none'.indexOf(options.auth) === -1) {
                 throw 'valid authentication schemas are : basic | token | cookie | any | none'
             }
-            logger.debug('options : ', options)
-            logger.debug('auth : ' + options.auth)
+            // logger.debug('options : ', options)
+            // logger.debug('auth : ' + options.auth)
 
             let dest = "/"
             if (options.dest !== undefined) dest = options.dest
@@ -182,7 +299,7 @@ class AssetU extends Cmd {
 
     async cleanDestination(dest: string) {
 
-        const remoteList = await this.scanAssets()
+        const remoteList = await scanAssets(this.dbManager)
         for (let ind = 0; ind < remoteList.length; ind++) {
             const fd = remoteList[ind]
             if (fd.path.startsWith(dest)) {
@@ -208,11 +325,11 @@ class AssetU extends Cmd {
             dirName = source + '/'
         }
 
-        logger.debug('options', options)
+        // logger.debug('options', options)
 
         this.scanDir(dirName, localList)
 
-        const remoteList = await this.scanAssets()
+        const remoteList = await scanAssets(this.dbManager)
 
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList)
 
@@ -268,35 +385,6 @@ class AssetU extends Cmd {
         return result
     }
 
-
-    //----------------------------------------------------------------------------------------------
-    // scanAssets
-    //----------------------------------------------------------------------------------------------
-
-    async scanAssets() {
-        const result: FileDescriptor[] = []
-        if (this.dbManager === undefined) throw 'dbManager undefined'
-        const dbReq = new DBExecuteRequest()
-        dbReq.selectFromTable = 'cyk_asset'
-        const pFields = dbReq.parameters.addVariable('fields', this.dbManager.scope.structure.stringDataType)
-        pFields.data = new PrimitiveData(this.dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype")
-        const xmlResult = await this.dbManager.dbExecute(dbReq)
-        if (xmlResult === undefined || xmlResult === null) throw 'xmlResult null or undefined'
-        const tag = parseXML('scanAssets', xmlResult)
-        const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope) as ObjectData
-        const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
-        for (let ind = 0; ind < rows.list.length; ind++) {
-            const { variable: row } = rows.list[ind]
-            const record = row.data as ObjectData
-            const asset_id = (record.variables.getData('asset_id') as PrimitiveData).value as number
-            const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
-            const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData)?.value as Date
-            // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id })
-        }
-        return result
-    }
-
     //----------------------------------------------------------------------------------------------
     // scanDir
     //----------------------------------------------------------------------------------------------
@@ -354,7 +442,7 @@ class AssetU extends Cmd {
     //----------------------------------------------------------------------------------------------
 
     async uploadAsset(upload: FileDescriptor, route: string, auth?: string) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
+        // logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
 
         try {
             let dbAsset: DBAsset | undefined = await this.dbManager?.dbAssetExist(route)

package/src/Cmd.ts

@@ -23,7 +23,7 @@ export class Cmd extends Command {
 
         const structure = new Structure()
         if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
-        logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL)
+        logger.info('Cyk server: ' + process.env.DBREMOTE_URL)
         const nodeCrypto = new NodeCrypto()
         this.dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
         const login = await this.dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)

package/src/DBClient.ts

@@ -1,4 +1,4 @@
-import { BasicType, DBColumn, DBExecuteRequest, DBManager, DBTable, ObjectData, parseXML, PrimitiveData, Script, XmlError } from "@cyklang/core";
+import { BasicType, DBColumn, DBExecuteRequest, DBManager, DBTable, ObjectData, parseXML, PrimitiveData, Script, variable2json, XmlError } from "@cyklang/core";
 import loglevel from "loglevel";
 import { errorconsole } from "./console";
 const logger = loglevel.getLogger('DBClient.ts')
@@ -47,9 +47,11 @@ export class DBClient {
     async runQuery() {
 
     }
-    
+
     async selectFromTable(title: string, tableName: string, options:
-        { fields: string, sort?: string | undefined, where?: string | undefined, width?: string | undefined }) {
+        { fields: string, sort?: string | undefined, where?: string | undefined, width?: string | undefined }): Promise<any[]> {
+
+        let result: any[] = []
 
         try {
 
@@ -107,8 +109,13 @@ export class DBClient {
 
             const objDataset = objXmlResult.variables.getData(tableName) as ObjectData
             for (let ind = 0; ind < objDataset.variables.length(); ind++) {
-                const record = (objDataset.variables.at(ind)?.data as ObjectData)
-                list.addObjectData(record)
+                const variable = objDataset.variables.at(ind)
+                if (variable) {
+                    const record = (variable?.data as ObjectData)
+                    list.addObjectData(record)
+                    result.push(variable2json(variable))
+                }
+
             }
             logger.info(list.renderList(title))
 
@@ -116,6 +123,7 @@ export class DBClient {
         catch (err) {
             logger.error(err)
         }
+        return result
     }
 
     async deleteModule(dbname: string) {
@@ -124,7 +132,7 @@ export class DBClient {
             const dbModule = await this.dbManager.dbModuleExist(dbname)
 
             if (dbModule === undefined) {
-               throw ('Module ' + dbname + ' not found')
+                throw ('Module ' + dbname + ' not found')
             }
             await this.dbManager.dbModuleDelete(dbModule)
         }
@@ -217,7 +225,7 @@ class List {
         }
         this.lines.push(this.renderSeparator())
         this.lines.push('Number of lines : ' + this.rows.length)
-        
+
         return this.lines.join('\n')
     }
 
@@ -272,7 +280,7 @@ class List {
         }
 
         // replace \n with a space
-        result = result.replace(/\n/, ' ') 
+        result = result.replace(/\n/, ' ')
 
         if (width !== undefined && width !== 0) {
             if (result.length >= width) {

package/src/InstallCommand.ts

@@ -0,0 +1,71 @@
+import { Cmd } from "./Cmd";
+import * as fs from "fs"
+import * as path from "path"
+
+import loglevel from 'loglevel'
+import { uploadModule } from "./ModuleCommand";
+const logger = loglevel.getLogger('InstallCommand.ts')
+logger.setLevel('debug')
+
+export class InstallCommand extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('upload Cyk modules to a Cyk server from a Node package downloaded by "npm install" ')
+            .argument('<node_package>', 'Node Package installed as dependency')
+            .action(async (node_package: any, options: any) => {
+                await this.install(node_package, options)
+            })
+    }
+
+    async install(node_package: string, options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+            await this.verifyPackageJson(node_package)
+
+            const xmlFolder = path.join('node_modules', node_package, 'xml')
+            if (!fs.existsSync(xmlFolder) || !fs.statSync(xmlFolder).isDirectory()) {
+                throw 'xml folder not found ( ' + xmlFolder + ' )'
+            }
+
+            const files = fs.readdirSync(xmlFolder)
+            for (let ind = 0; ind < files.length; ind++) {
+                const file = files[ind]
+                await uploadModule(path.join(xmlFolder, file), this.dbManager)
+            }
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * method verifyPackageJson
+     * @param node_package 
+     */
+    async verifyPackageJson(node_package: string) {
+
+        let packageJson: any
+
+        try {
+            // Lecture du contenu du fichier package.json en tant que chaîne de caractères
+            const packageJsonContent = fs.readFileSync('package.json', 'utf8');
+
+            // Analyse du contenu en tant qu'objet JSON
+            packageJson = JSON.parse(packageJsonContent);
+
+        } catch (error) {
+            console.error('Error loading package.json file :', error);
+            throw error
+        }
+
+        if (!packageJson.dependencies || !packageJson.dependencies[node_package]) {
+            throw node_package + ' not installed in the current project. Install it first with "npm install"'
+        }
+
+
+
+    }
+
+
+}

package/src/ModuleCommand.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { DBModule, parseXML } from "@cyklang/core"
+import { DBManager, DBModule, parseXML } from "@cyklang/core"
 import * as fs from "fs"
 import loglevel from 'loglevel'
 import path from "path"
@@ -115,30 +115,7 @@ class ModuleU extends Cmd {
             else {
                 for (let ind = 0; ind < files.length; ind++) {
                     const file = files[ind]
-                    const dbname = getModuleDBName(file)
-                    const source = fs.readFileSync(file).toString()
-                    const tag = parseXML(dbname, source)
-                    const dbModuleExist = await this.dbManager.dbModuleExist(dbname)
-                    if (dbModuleExist === undefined) {
-                        // insert
-                        const dbModule = new DBModule()
-                        dbModule.source = source
-                        dbModule.dbname = dbname
-                        dbModule.access = tag.attributes.ACCESS
-                        dbModule.description = tag.attributes.DESCRIPTION
-                        logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description)
-                        const id = await this.dbManager.dbModuleInsert(dbModule)
-                        logger.info('module ' + dbname + ' added with ID ' + id)
-                    }
-                    else {
-                        // update
-                        dbModuleExist.source = source
-                        dbModuleExist.access = tag.attributes.ACCESS
-                        dbModuleExist.description = tag.attributes.DESCRIPTION
-                        logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description)
-                        await this.dbManager.dbModuleUpdate(dbModuleExist)
-                        logger.info('module ' + dbname + ' updated')
-                    }
+                    await uploadModule(file, this.dbManager)
                 }
             }
         }
@@ -148,6 +125,38 @@ class ModuleU extends Cmd {
     }
 }
 
+/**
+ * 
+ * @param file 
+ * @param dbManager 
+ */
+export async function uploadModule(file: string, dbManager: DBManager) {
+    const dbname = getModuleDBName(file)
+    const source = fs.readFileSync(file).toString()
+    const tag = parseXML(dbname, source)
+    const dbModuleExist = await dbManager.dbModuleExist(dbname)
+    if (dbModuleExist === undefined) {
+        // insert
+        const dbModule = new DBModule()
+        dbModule.source = source
+        dbModule.dbname = dbname
+        dbModule.access = tag.attributes.ACCESS
+        dbModule.description = tag.attributes.DESCRIPTION
+        // logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description)
+        const id = await dbManager.dbModuleInsert(dbModule)
+        logger.info('module ' + dbname + ' added with ID ' + id)
+    }
+    else {
+        // update
+        dbModuleExist.source = source
+        dbModuleExist.access = tag.attributes.ACCESS
+        dbModuleExist.description = tag.attributes.DESCRIPTION
+        // logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description)
+        await dbManager.dbModuleUpdate(dbModuleExist)
+        logger.info('module ' + dbname + ' updated')
+    }
+}
+
 interface DownloadOptions {
     id: string | undefined
     env: string | undefined

package/src/OpenCommand.ts

@@ -0,0 +1,31 @@
+import { Cmd } from "./Cmd";
+
+import loglevel from 'loglevel'
+const logger = loglevel.getLogger('OpenCommand.ts')
+logger.setLevel('debug')
+
+export class OpenCommand extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('open browser').version('0.1')
+            .argument('<module>', 'module to execute')
+            .action(async (module: any, options: any) => {
+                await this.openBrowser(module, options)
+            })
+    }
+
+    async openBrowser(module: string, options: any) {
+        try {
+            await this.prologue(options)
+
+            if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
+            const url = process.env.DBREMOTE_URL + '/cyk/#/run/' + module;
+            const open = await import('open');
+            open.default(url)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+}

package/src/RunCommand.ts

@@ -8,8 +8,8 @@ loglevel.setLevel('debug')
 const logger = loglevel.getLogger('RunCommand.ts');
 
 export class RunCommand extends Cmd {
-    constructor() {
-        super('run')
+    constructor(name: string) {
+        super(name)
         this.description('run module').version('0.2')
             .argument('<files...>', 'local module file(s) to run')
             .action(async (files: any, options: any) => {

package/src/index.ts

@@ -7,8 +7,9 @@ import { QueryCommand } from './QueryCommand'
 import { TableCommand } from './TableCommand'
 import { TestCommand } from './TestCommand'
 import { RunCommand } from './RunCommand'
-import { InitCommand } from './InitCommand'
+import { InstallCommand } from './InstallCommand'
 import { AssetCommand } from './AssetCommand'
+import { OpenCommand } from './OpenCommand'
 const logger = loglevel.getLogger("index.ts")
 logger.setLevel("debug")
 
@@ -16,7 +17,8 @@ const program = new Command()
 program.name('cyk').description('cyklang CLI')
     .version('0.2')
 
-program.addCommand(new InitCommand('init'))
+program.addCommand(new InstallCommand('install'))
+program.addCommand(new InstallCommand('i'))
 program.addCommand(new AssetCommand('asset', 'manage assets'))
 program.addCommand(new AssetCommand('a', 'manage assets'))
 program.addCommand(new ModuleCommand('module'))
@@ -28,6 +30,9 @@ program.addCommand(new QueryCommand('q'))
 program.addCommand(new TableCommand('table'))
 program.addCommand(new TableCommand('t'))
 program.addCommand(new TestCommand())
-program.addCommand(new RunCommand())
+program.addCommand(new RunCommand('run'))
+program.addCommand(new RunCommand('r'))
+program.addCommand(new OpenCommand('open'))
+program.addCommand(new OpenCommand('o'))
 
 program.parse()

package/test/t27.output

@@ -0,0 +1,2 @@
+150
+{"user_id":1,"user_name":"cyk","user_email":"cyk@gmail.com","user_password":"$2b$10$Et1b0DodTNKxW/jvUFC8be8JrRXULHWC5RnwOjVhUXmVKv.CyfFW.","user_access":"admin","user_appli":null,"user_disable":false,"user_lang":null}

package/test/t27.xml

@@ -0,0 +1,18 @@
+<?xml-model href="https://www.cyklang.net/schema/cyklang.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<module>
+    <print>objson('150')</print>
+    <string name="chaine" literal=""><![CDATA[ 
+        {
+            "user_id": 1,
+            "user_name": "cyk",
+            "user_email": "cyk@gmail.com",
+            "user_password": "$2b$10$Et1b0DodTNKxW/jvUFC8be8JrRXULHWC5RnwOjVhUXmVKv.CyfFW.",
+            "user_access": "admin",
+            "user_appli": null,
+            "user_disable": false,
+            "user_lang": null
+          }
+        ]]>
+    </string>
+    <print>json(objson(chaine))</print>
+</module>

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "es2020",
-    "module": "commonjs",
+    "module": "Node16",
     "declaration": true,
     "outDir": "./build",
     "strict": true,