dazscript-framework 0.1.16 → 0.2.1

package/dist/scripts/install-generator.js

@@ -2,36 +2,13 @@ const tsFileParser = require('ts-file-parser');
 const fs = require('fs');
 const path = require('path');
 const glob = require('glob');
-const { program } = require('commander');
-
-program
-  .requiredOption(
-    '-p, --scriptsPath <path>',
-    'Specify the path to your scripts'
-  )
-  .option(
-    '-m, --defaultMenuPath [path]',
-    'Specify the default menu path',
-    'My Scripts'
-  )
-  .parse(process.argv);
-let options = program.opts();
 
 const nameofActionDecorator = 'action';
 
-const scriptsPath = options.scriptsPath.endsWith('/')
-  ? options.scriptsPath
-  : options.scriptsPath + '/';
-const defaultMenuPath = options.defaultMenuPath.endsWith('/')
-  ? options.defaultMenuPath
-  : options.defaultMenuPath + '/';
-
-const container = { scripts: [] };
-
 function getPartialPath(filePath) {
   const fileInfo = path.parse(filePath);
   const dir = fileInfo.dir.replace('/src', '').replace(/^\.\//, '');
-  return `${dir}/${fileInfo.name}`;
+  return dir ? `${dir}/${fileInfo.name}` : fileInfo.name;
 }
 
 function compareStrings(a, b) {
@@ -58,7 +35,7 @@ uninstall(${data});
 `;
 }
 
-function processScript(filePath) {
+function processScript(filePath, container, defaultMenuPath) {
   const fileInfo = path.parse(filePath);
   const content = fs.readFileSync(filePath, 'utf-8').toString();
   const json = tsFileParser.parseStruct(content, {}, filePath);
@@ -79,7 +56,12 @@ function processScript(filePath) {
         decorator.bundle === undefined
           ? getPartialPath(filePath)
           : fileInfo.name.replace('.ts', ''),
-      menuPath: `${defaultMenuPath}${path.parse(getPartialPath(filePath)).dir}`,
+      menuPath: (() => {
+        const relativeDir = path.parse(getPartialPath(filePath)).dir;
+        return relativeDir && relativeDir !== '.'
+          ? `${defaultMenuPath}${relativeDir}`
+          : defaultMenuPath.replace(/\/$/, '');
+      })(),
       description: fileInfo.name.replace('.dsa', ''),
       group: stringOrDefault(decorator.group, undefined),
       shortcut: stringOrDefault(decorator.shortcut),
@@ -144,42 +126,73 @@ function processScript(filePath) {
   });
 }
 
-function processScripts(paths) {
+function processScripts(paths, container, defaultMenuPath) {
   paths.forEach((filePath) => {
     console.log(`Processing ${filePath}`);
-    processScript(filePath);
+    processScript(filePath, container, defaultMenuPath);
   });
 }
 
-function generate() {
-  glob(`${scriptsPath}/**/*.dsa.ts`, function (err, paths) {
-    if (err) {
-      console.error('Error while globbing:', err);
-      return;
-    }
+function generateInstallerFiles(workdir, options) {
+  const scriptsPath = options.scriptsPath.endsWith('/')
+    ? options.scriptsPath
+    : `${options.scriptsPath}/`;
+  const defaultMenuPath = options.defaultMenuPath.endsWith('/')
+    ? options.defaultMenuPath
+    : `${options.defaultMenuPath}/`;
+  const container = { scripts: [] };
+  const matches = glob.sync(`${scriptsPath}/**/*.dsa.ts`, { cwd: workdir });
+
+  processScripts(matches, container, defaultMenuPath);
+
+  container.scripts = container.scripts.sort((a, b) => {
+    const aKey = a.menuPath + a.filePath;
+    const bKey = b.menuPath + b.filePath;
+    return compareStrings(aKey, bKey);
+  });
 
-    processScripts(paths);
+  const installerScriptContent = generateInstallerTemplate(
+    JSON.stringify(container.scripts, null, 4)
+  );
+  fs.writeFileSync(path.join(workdir, 'src', 'Install.dsa.ts'), installerScriptContent);
+
+  const uninstallerScriptContent = generateUninstallerTemplate(
+    JSON.stringify(container.scripts, null, 4)
+  );
+  fs.writeFileSync(
+    path.join(workdir, 'src', 'Uninstall.dsa.ts'),
+    uninstallerScriptContent
+  );
+}
 
-    container.scripts = container.scripts.sort((a, b) => {
-      const aKey = a.menuPath + a.filePath;
-      const bKey = b.menuPath + b.filePath;
-      return compareStrings(aKey, bKey);
-    });
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const options = {
+    scriptsPath: './src',
+    defaultMenuPath: 'My Scripts',
+  };
 
-    // Generate the InstallerScript class and call install function
-    const installerScriptContent = generateInstallerTemplate(
-      JSON.stringify(container.scripts, null, 4)
-    );
-    let outputFilePath = './src/Install.dsa.ts';
-    fs.writeFileSync(outputFilePath, installerScriptContent);
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
 
-    const uninstallerScriptContent = generateUninstallerTemplate(
-      JSON.stringify(container.scripts, null, 4)
-    );
-    outputFilePath = './src/Uninstall.dsa.ts';
-    fs.writeFileSync(outputFilePath, uninstallerScriptContent);
-  });
+    if (arg === '--scripts-path' || arg === '-p') {
+      options.scriptsPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--menu-path' || arg === '--defaultMenuPath' || arg === '-m') {
+      options.defaultMenuPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  generateInstallerFiles(process.cwd(), options);
 }
 
-// Call the generate function at the end of the script
-generate();
+module.exports = {
+  generateInstallerFiles,
+};

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "dazscript-framework",
-  "version": "0.1.16",
+  "version": "0.2.1",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",
   "scripts": {
     "prepare": "node ./scripts/install-git-hooks.js",
-    "prebuild": "npm run installer",
-    "build": "webpack --env outputPath=./out",
-    "postbuild": "npm run icons",
-    "watch": "webpack --env outputPath=./out --watch",
-    "icons": "copyfiles -u 1 src/**/*.png out/",
-    "installer": "node ./dist/scripts/install-generator.js -p ./src/samples -m /DazScriptFramework"
+    "prebuild": "node ./dist/scripts/cli.js installer --scripts-path ./src/samples --menu-path /DazScriptFramework",
+    "build": "node ./dist/scripts/cli.js build --out-dir ./out",
+    "postbuild": "node ./dist/scripts/cli.js icons --out-dir ./out",
+    "watch": "node ./dist/scripts/cli.js watch --out-dir ./out",
+    "icons": "node ./dist/scripts/cli.js icons --out-dir ./out",
+    "installer": "node ./dist/scripts/cli.js installer --scripts-path ./src/samples --menu-path /DazScriptFramework"
+  },
+  "bin": {
+    "dazscript": "./dist/scripts/cli.js"
   },
   "keywords": [
     "daz3d",
@@ -24,8 +27,7 @@
   "exports": {
     "./webpack": "./webpack.config.js",
     "./babel": "./babel.config.js",
-    "./babel/trace-babel-plugin": "./dist/babel/trace-babel-plugin.js",
-    "./babel/trace-log-babel-plugin": "./dist/babel/trace-log-babel-plugin.js"
+    "./config": "./dist/config.js"
   },
   "files": [
     "tsconfig.json",
@@ -39,33 +41,32 @@
     "url": "git+https://github.com/fjdiazt/dazscript-framework.git"
   },
   "peerDependencies": {
+    "dazscript-types": "^0.2.3"
+  },
+  "dependencies": {
     "@babel/core": "^7.23.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-proposal-decorators": "^7.23.2",
     "@babel/plugin-transform-arrow-functions": "^7.22.5",
     "@babel/plugin-transform-block-scoping": "^7.23.0",
+    "@babel/plugin-transform-class-properties": "^7.25.9",
+    "@babel/plugin-transform-private-methods": "^7.27.1",
+    "@babel/plugin-transform-private-property-in-object": "^7.27.1",
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.23.2",
-    "@babel/types": "^7.26.3",
     "babel-core": "^6.26.3",
     "babel-loader": "^9.1.3",
-    "babel-loader-exclude-node-modules-except": "^1.2.1",
     "babel-plugin-transform-class-properties": "^6.24.1",
     "babel-plugin-transform-typescript-metadata": "^0.3.2",
-    "commander": "^11.1.0",
-    "cross-env": "^7.0.3",
-    "dazscript-types": "^0.2.3",
     "glob": "^7.2.0",
     "ts-file-parser": "^0.0.21",
     "ts-loader": "^9.5.0",
     "tsconfig-paths-webpack-plugin": "^4.1.0",
     "typescript": "^5.2.2",
-    "webpack": "^5.88.2",
-    "webpack-cli": "^5.1.4"
+    "webpack": "^5.88.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
-    "copyfiles": "^2.4.1",
     "eslint": "^9.17.0",
     "typescript": "^5.7.3"
   }

package/src/helpers/http-helper.ts

@@ -17,6 +17,7 @@ export interface HttpRequestOptions {
     path: string
     method?: HttpMethod
     connectionMode?: HttpConnectionMode
+    timeoutMs?: number
     responseType?: HttpResponseType
     queryString?: string
     headers?: Record<string, string>
@@ -76,6 +77,9 @@ export const request = <T = any>(options: HttpRequestOptions): HttpResponse<T> =
     const http = options.transport ?? new DzHttpHelper()
     http.setConnectionMode(options.connectionMode ?? 'https')
     http.setHost(hostOnly)
+    if (typeof http.setTimeoutMs === 'function' && options.timeoutMs && options.timeoutMs > 0) {
+        http.setTimeoutMs(options.timeoutMs)
+    }
     if (port > 0) {
         http.setPort(port)
     }

package/webpack.config.js

@@ -3,24 +3,33 @@ const glob = require('glob');
 const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
 
 module.exports = (env, argv) => {
+  const projectRoot =
+    env && env.context ? path.resolve(env.context) : process.cwd();
+  const sourceRoot = path.resolve(projectRoot, 'src');
   const isFileSpecified = env && env.file;
   const entryFiles = isFileSpecified
-    ? [`./src/${env.file}.dsa.ts`]
-    : glob.sync('./src/**/*.dsa.ts');
+    ? [path.resolve(sourceRoot, `${env.file}.dsa.ts`)]
+    : glob
+        .sync(path.join(sourceRoot, '**/*.dsa.ts').replace(/\\/g, '/'))
+        .map((filePath) => path.resolve(filePath));
 
   const outputPath =
     env && env.outputPath
-      ? path.resolve(env.outputPath)
+      ? path.resolve(projectRoot, env.outputPath)
       : path.resolve(__dirname, 'out');
 
   return {
+    context: projectRoot,
     mode: 'production',
     optimization: {
       usedExports: true,
     },
     entry: entryFiles.reduce((acc, filePath) => {
-      const entry = filePath.replace('.dsa.ts', '').replace('src/', '');
-      acc[entry] = `./${filePath}`;
+      const entry = path
+        .relative(sourceRoot, filePath)
+        .replace(/\\/g, '/')
+        .replace('.dsa.ts', '');
+      acc[entry] = filePath;
       return acc;
     }, {}),
     module: {
@@ -30,6 +39,7 @@ module.exports = (env, argv) => {
           use: [
             {
               loader: 'babel-loader',
+              options: require('./babel.config.js'),
             },
             {
               loader: 'ts-loader',
@@ -40,7 +50,7 @@ module.exports = (env, argv) => {
           ],
           exclude: [
             {
-              and: [path.resolve(__dirname, 'node_modules')],
+              and: [path.resolve(projectRoot, 'node_modules')],
               not: [
                 path.resolve(__dirname, 'node_modules/dazscript-framework/src'),
               ],
@@ -51,7 +61,18 @@ module.exports = (env, argv) => {
     },
     resolve: {
       extensions: ['.ts'],
-      plugins: [new TsconfigPathsPlugin()],
+      plugins: [
+        new TsconfigPathsPlugin({
+          configFile: path.resolve(projectRoot, 'tsconfig.json'),
+        }),
+      ],
+    },
+    resolveLoader: {
+      modules: [
+        path.resolve(__dirname, 'node_modules'),
+        path.resolve(projectRoot, 'node_modules'),
+        'node_modules',
+      ],
     },
     output: {
       filename: '[name].dsa',

package/dist/babel/trace-babel-plugin.js

@@ -1,243 +0,0 @@
-const t = require('@babel/types');
-const path = require('path');
-let globalEnable = true;
-let enabled = false;
-
-function isTraceDecorator(node) {
-  return false; // Your existing isTraceDecorator logic
-}
-
-function isTraceComment(node) {
-  return false; // Your existing isTraceComment logic
-}
-
-function createConsoleLogStatement(
-  location,
-  filename,
-  lineNumber,
-  functionName,
-  parameters
-) {
-  const filenameWithoutPath = path.basename(filename);
-  let logMessage = `[TRACE] ${location}: ${filenameWithoutPath}(${lineNumber}): ${functionName}`;
-
-  if (parameters.length > 0) {
-    logMessage += `(${parameters.join(', ')})`;
-  } else {
-    logMessage += '()';
-  }
-
-  return t.blockStatement([
-    t.expressionStatement(
-      t.callExpression(
-        t.memberExpression(t.identifier('App'), t.identifier('debug')),
-        [t.stringLiteral(logMessage)]
-      )
-    ),
-    t.expressionStatement(
-      t.callExpression(
-        t.memberExpression(t.identifier('App'), t.identifier('flushLogBuffer')),
-        []
-      )
-    ),
-  ]);
-}
-
-function processFunction(enabled, path, state) {
-  const filename = state.file.opts.filename || 'unknown';
-  const lineNumber = path.node.loc?.start?.line || 'unknown';
-  const functionName = path.node.id ? path.node.id.name : 'anonymous';
-  const parameters = path.node.params.map((param) => param.name);
-
-  if (!enabled || functionName === 'anonymous' || lineNumber === 'unknown')
-    return;
-
-  const enteringLogStatement = createConsoleLogStatement(
-    'Entering',
-    filename,
-    lineNumber,
-    functionName,
-    parameters
-  );
-  const exitingLogStatement = createConsoleLogStatement(
-    'Exiting',
-    filename,
-    lineNumber,
-    functionName,
-    parameters
-  );
-
-  // Process the return statements within the function body
-  path.get('body').traverse({
-    ReturnStatement(returnPath) {
-      returnPath.insertBefore(exitingLogStatement);
-    },
-  });
-
-  if (enteringLogStatement) {
-    if (t.isBlockStatement(path.node.body)) {
-      path.node.body.body.unshift(enteringLogStatement);
-    } else {
-      path.node.body = t.blockStatement([enteringLogStatement, path.node.body]);
-    }
-  }
-}
-
-function processAssignmentExpression(path, state) {
-  const filename = state.file.opts.filename || 'unknown';
-  const lineNumber = path.node.loc?.start?.line || 'unknown';
-  let functionName = 'anonymous'; // Default value for function name
-  const parameters = [];
-
-  if (!enabled || lineNumber === 'unknown') return;
-
-  if (t.isMemberExpression(path.node.left)) {
-    functionName = path.node.left.property.name;
-  }
-
-  const enteringLogStatement = createConsoleLogStatement(
-    'Entering',
-    filename,
-    lineNumber,
-    functionName,
-    parameters
-  );
-  const exitingLogStatement = createConsoleLogStatement(
-    'Exiting',
-    filename,
-    lineNumber,
-    functionName,
-    parameters
-  );
-
-  // Process the return statements within the function body
-  path.get('right').traverse({
-    ReturnStatement(returnPath) {
-      returnPath.insertBefore(exitingLogStatement);
-    },
-  });
-
-  if (
-    t.isFunctionExpression(path.node.right) ||
-    t.isArrowFunctionExpression(path.node.right)
-  ) {
-    // Handle the case where the right-hand side is a function expression or arrow function expression
-    if (t.isBlockStatement(path.node.right.body)) {
-      path.node.right.body.body.unshift(enteringLogStatement);
-      path.node.right.body.body.push(exitingLogStatement);
-    } else {
-      path.node.right.body = t.blockStatement([
-        enteringLogStatement,
-        t.returnStatement(path.node.right.body),
-        exitingLogStatement,
-      ]);
-    }
-  }
-}
-
-function processVariableDeclaration(path, state) {
-  const filename = state.file.opts.filename || 'unknown';
-  const lineNumber = path.node.loc?.start?.line || 'unknown';
-
-  path.node.declarations.forEach((declarator) => {
-    if (
-      t.isFunctionExpression(declarator.init) ||
-      t.isArrowFunctionExpression(declarator.init)
-    ) {
-      const functionName = declarator.id.name;
-      const parameters = declarator.init.params.map((param) => param.name);
-
-      if (!enabled || lineNumber === 'unknown') return;
-
-      const enteringLogStatement = createConsoleLogStatement(
-        'Entering',
-        filename,
-        lineNumber,
-        functionName,
-        parameters
-      );
-      const exitingLogStatement = createConsoleLogStatement(
-        'Exiting',
-        filename,
-        lineNumber,
-        functionName,
-        parameters
-      );
-
-      // Ensure the Exiting statement is added to the end of the function body
-      if (t.isBlockStatement(declarator.init.body)) {
-        declarator.init.body.body.push(exitingLogStatement);
-      } else {
-        declarator.init.body = t.blockStatement([
-          declarator.init.body,
-          exitingLogStatement,
-        ]);
-      }
-
-      // Process the return statements within the function body
-      declarator.init.body.body.forEach((statement, index) => {
-        if (t.isReturnStatement(statement)) {
-          // Add Exiting statement before the return statement
-          declarator.init.body.body.splice(index, 0, exitingLogStatement);
-        }
-      });
-
-      // Add the Entering statement at the beginning of the function body
-      if (t.isBlockStatement(declarator.init.body)) {
-        declarator.init.body.body.unshift(enteringLogStatement);
-      } else {
-        declarator.init.body = t.blockStatement([
-          enteringLogStatement,
-          t.returnStatement(declarator.init.body),
-        ]);
-      }
-    }
-  });
-}
-
-module.exports = function () {
-  let declarationFound = false;
-
-  return {
-    pre() {
-      if (this.opts && typeof this.opts.default === 'boolean') {
-        enabled = globalEnable = this.opts.default;
-      }
-      enabled = globalEnable;
-      declarationFound = false;
-    },
-    visitor: {
-      VariableDeclaration(path, state) {
-        const declarations = path.node.declarations;
-        const traceDeclaration = declarations.find(
-          (declaration) => declaration.id.name === 'TRACE'
-        );
-
-        if (!declarationFound) {
-          if (traceDeclaration) {
-            enabled = traceDeclaration.init
-              ? traceDeclaration.init.value
-              : false;
-            declarationFound = true;
-          } else {
-            enabled = globalEnable;
-          }
-        }
-
-        processVariableDeclaration(path, state);
-      },
-      FunctionDeclaration(path, state) {
-        //processFunction(path, state);
-      },
-      FunctionExpression(path, state) {
-        processFunction(enabled, path, state);
-      },
-      ArrowFunctionExpression(path, state) {
-        //processFunction(path, state);
-      },
-      AssignmentExpression(path, state) {
-        processAssignmentExpression(path, state);
-      },
-    },
-  };
-};