@ohos-ports/azle 0.33.0-beta.0

package/.scripts/class_migration/update_typescript.js

@@ -0,0 +1,99 @@
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const tsVersion = '^5.2.2';
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Check if node_modules directory exists
+const nodeModulesPath = path.join(process.cwd(), 'node_modules');
+const nodeModulesExists = fs.existsSync(nodeModulesPath);
+
+const doInstall = false;
+
+// Read the package.json file
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    // Parse the package.json content
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Update the TypeScript version in dependencies or devDependencies
+    if (packageJson.dependencies && packageJson.dependencies.typescript) {
+        packageJson.dependencies.typescript = tsVersion;
+    } else if (
+        packageJson.devDependencies &&
+        packageJson.devDependencies.typescript
+    ) {
+        packageJson.devDependencies.typescript = tsVersion;
+    } else {
+        console.error(
+            'TypeScript is not listed as a dependency in package.json.'
+        );
+        return;
+    }
+
+    // Write the updated package.json back to the file
+    fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(packageJson, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated package.json: ${writeErr}`
+                );
+                return;
+            }
+
+            console.info(
+                `package.json successfully updated with TypeScript version: ${tsVersion}`
+            );
+
+            // Run npm install
+            if (doInstall) {
+                exec('npm install', (installErr, stdout) => {
+                    if (installErr) {
+                        console.error(
+                            `Error running npm install: ${installErr}`
+                        );
+                        return;
+                    }
+
+                    console.info('npm install completed successfully');
+                    console.info(stdout);
+
+                    // Delete node_modules if it did not exist before
+                    if (!nodeModulesExists) {
+                        fs.rm(
+                            nodeModulesPath,
+                            { recursive: true, force: true },
+                            (rmErr) => {
+                                if (rmErr) {
+                                    console.error(
+                                        `Error removing node_modules directory: ${rmErr}`
+                                    );
+                                } else {
+                                    console.info(
+                                        'node_modules directory removed as it did not exist before running the script.'
+                                    );
+                                }
+                            }
+                        );
+                    }
+                });
+            }
+        }
+    );
+});

package/.scripts/clean_all_projects.ts

@@ -0,0 +1,91 @@
+#!/usr/bin/env tsx
+
+import { execSync } from 'child_process';
+import { existsSync, statSync } from 'fs'; // Keep some sync methods for simplicity
+import { readdir, rm } from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Recursively searches for Node.js projects and runs 'npx azle clean' on them
+ *
+ * @param directory - The directory to search in
+ */
+async function cleanProjects(directory: string): Promise<void> {
+    try {
+        // Check if this directory is a Node.js project
+        const isNodeProject = existsSync(path.join(directory, 'package.json'));
+
+        // If it's a Node.js project, run the clean command
+        if (isNodeProject) {
+            console.info(`Found Node.js project in: ${directory}`);
+            try {
+                console.info(`Running 'npx azle clean' in ${directory}...`);
+                execSync('npx azle clean', {
+                    cwd: directory,
+                    stdio: 'inherit' // Show output in console
+                });
+                await rm('.dfx', {
+                    recursive: true,
+                    force: true
+                });
+
+                console.info(`./.dfx directory deleted`);
+
+                await rm('node_modules', {
+                    recursive: true,
+                    force: true
+                });
+
+                console.info(`./node_modules directory deleted`);
+                console.info(`Successfully cleaned project in ${directory}`);
+            } catch (error) {
+                console.error(
+                    `Error cleaning project in ${directory}: ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+
+        // Read all entries in the current directory
+        const entries = await readdir(directory);
+
+        // Process subdirectories
+        for (const entry of entries) {
+            // Skip node_modules directories
+            if (entry === 'node_modules') {
+                continue;
+            }
+
+            const fullPath = path.join(directory, entry);
+
+            // Check if this is a directory
+            const stats = statSync(fullPath); // Using sync for simplicity in the loop
+            if (stats.isDirectory()) {
+                // Recursively process this subdirectory
+                await cleanProjects(fullPath);
+            }
+        }
+    } catch (error) {
+        console.error(
+            `Error processing directory ${directory}: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+}
+
+async function main(): Promise<void> {
+    // Get the starting directory from command line or use examples directory relative to script location
+    const scriptPath = fileURLToPath(import.meta.url);
+    const scriptDir = path.dirname(scriptPath);
+    const startDirectory =
+        process.argv[2] || path.join(scriptDir, '..', 'examples');
+
+    console.info(
+        `Starting to search for Node.js projects in: ${startDirectory}`
+    );
+
+    // Start the recursive search and cleaning
+    await cleanProjects(startDirectory);
+    console.info('Finished cleaning all Node.js projects.');
+}
+
+main();

package/.scripts/delete_git_branches.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# List of branches to delete
+branches=(
+    "my_branch1"
+    "my_branch2"
+)
+
+# Function to delete branches locally and on GitHub
+delete_branch() {
+  local branch=$1
+
+  git branch -d "$branch"
+  git push --delete origin "$branch"
+}
+
+# Iterate over the branches and delete them
+for branch in "${branches[@]}"; do
+  delete_branch "$branch"
+done

package/.scripts/dev_dependencies/add_dev_dependencies.js

@@ -0,0 +1,53 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Define the standard dev dependencies we want to add
+const standardDevDependencies = {
+    async_await_end_to_end_test_functional_syntax:
+        'file:../../functional_syntax/async_await'
+};
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Read the package.json file
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    // Parse the package.json content
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Add the standard devDependencies
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        ...standardDevDependencies
+    };
+
+    // Write the updated package.json back to the file
+    fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(packageJson, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated package.json: ${writeErr}`
+                );
+                return;
+            }
+
+            console.info(
+                'Successfully added standard devDependencies to package.json'
+            );
+        }
+    );
+});

package/.scripts/dev_dependencies/remove_dev_dependencies.js

@@ -0,0 +1,44 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Read the package.json file
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    // Parse the package.json content
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    // Remove devDependencies
+    delete packageJson.devDependencies;
+
+    // Write the updated package.json back to the file
+    fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(packageJson, null, 2),
+        'utf8',
+        (writeErr) => {
+            if (writeErr) {
+                console.error(
+                    `Error writing updated package.json: ${writeErr}`
+                );
+                return;
+            }
+
+            console.info(
+                'Successfully removed devDependencies from package.json'
+            );
+        }
+    );
+});