@ohos-ports/azle 0.33.0-beta.0

package/.scripts/survey_examples.ts

@@ -0,0 +1,396 @@
+#!/usr/bin/env tsx
+
+// import { execSync } from 'child_process';
+import { existsSync, statSync } from 'fs';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Project information structure
+ */
+type ProjectInfo = {
+    path: string;
+    category: string;
+    subcategory: string;
+    packageJson: {
+        name?: string;
+        version?: string;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    };
+    fileCount: number;
+    size: number; // Size in bytes
+};
+
+/**
+ * Summary information structure
+ */
+type SummaryInfo = {
+    totalProjects: number;
+    categories: Record<string, number>;
+    subcategories: Record<string, number>;
+    dependencies: {
+        name: string;
+        count: number;
+        projects: string[];
+    }[];
+    averageFileCount: number;
+    averageSize: number; // Size in bytes
+};
+
+/**
+ * Calculate total size of a directory in bytes
+ *
+ * @param directory - Directory to calculate size for
+ * @returns Size in bytes
+ */
+const calculateDirectorySize = async (directory: string): Promise<number> => {
+    let totalSize = 0;
+
+    try {
+        const entries = await fs.readdir(directory);
+
+        for (const entry of entries) {
+            if (
+                entry === 'node_modules' ||
+                entry === '.git' ||
+                entry === '.dfx' ||
+                entry === '.azle'
+            ) {
+                continue;
+            }
+
+            const fullPath = path.join(directory, entry);
+
+            try {
+                const stats = statSync(fullPath);
+
+                if (stats.isDirectory()) {
+                    totalSize += await calculateDirectorySize(fullPath);
+                } else {
+                    totalSize += stats.size;
+                }
+            } catch (_error) {
+                // Skip files with permission issues
+                continue;
+            }
+        }
+    } catch (_error) {
+        // If directory read fails, return 0
+    }
+
+    return totalSize;
+};
+
+/**
+ * Count files in a directory
+ *
+ * @param directory - Directory to count files in
+ * @returns File count
+ */
+const countFiles = async (directory: string): Promise<number> => {
+    let fileCount = 0;
+
+    try {
+        const entries = await fs.readdir(directory);
+
+        for (const entry of entries) {
+            if (
+                entry === 'node_modules' ||
+                entry === '.git' ||
+                entry === '.dfx' ||
+                entry === '.azle'
+            ) {
+                continue;
+            }
+
+            const fullPath = path.join(directory, entry);
+
+            try {
+                const stats = statSync(fullPath);
+
+                if (stats.isDirectory()) {
+                    fileCount += await countFiles(fullPath);
+                } else {
+                    fileCount += 1;
+                }
+            } catch (_error) {
+                // Skip files with permission issues
+                continue;
+            }
+        }
+    } catch (_error) {
+        // If directory read fails, return 0
+    }
+
+    return fileCount;
+};
+
+/**
+ * Recursively searches for Node.js projects and collects information about them
+ *
+ * @param directory - The directory to search in
+ * @param projects - Array to collect project information
+ */
+const surveyProjects = async (
+    directory: string,
+    projects: ProjectInfo[]
+): 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, collect information
+        if (isNodeProject) {
+            console.info(`Found Node.js project in: ${directory}`);
+
+            try {
+                // Determine category and subcategory from path
+                const relPath = path.relative(process.cwd(), directory);
+                const pathParts = relPath.split(path.sep);
+                let category = 'unknown';
+                let subcategory = 'unknown';
+
+                // Examples structure typically follows examples/{stable|experimental}/test|demo/...
+                if (pathParts.length >= 2 && pathParts[0] === 'examples') {
+                    category = pathParts[1] || 'unknown'; // stable or experimental
+                    subcategory = pathParts[2] || 'unknown'; // test or demo or something else
+                }
+
+                // Read package.json
+                const packageJsonPath = path.join(directory, 'package.json');
+                let packageJson: any = {};
+
+                try {
+                    const packageJsonContent = await fs.readFile(
+                        packageJsonPath,
+                        'utf8'
+                    );
+                    packageJson = JSON.parse(packageJsonContent);
+                } catch (_error) {
+                    // If package.json can't be read or parsed, continue with empty object
+                }
+
+                // Calculate file count and size
+                const fileCount = await countFiles(directory);
+                const size = await calculateDirectorySize(directory);
+
+                // Create project info object
+                const projectInfo: ProjectInfo = {
+                    path: directory,
+                    category,
+                    subcategory,
+                    packageJson,
+                    fileCount,
+                    size
+                };
+
+                // Add to projects array
+                projects.push(projectInfo);
+            } catch (error) {
+                console.error(
+                    `Error analyzing project in ${directory}: ${error instanceof Error ? error.message : String(error)}`
+                );
+            }
+        }
+
+        // Read all entries in the current directory
+        const entries = await fs.readdir(directory);
+
+        // Process subdirectories
+        for (const entry of entries) {
+            // Skip node_modules directories
+            if (
+                entry === 'node_modules' ||
+                entry === '.git' ||
+                entry === '.dfx' ||
+                entry === '.azle'
+            ) {
+                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 surveyProjects(fullPath, projects);
+            }
+        }
+    } catch (error) {
+        console.error(
+            `Error processing directory ${directory}: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+};
+
+/**
+ * Generate a summary of the surveyed projects
+ *
+ * @param projects - Array of project information
+ * @returns Summary information
+ */
+const generateSummary = (projects: ProjectInfo[]): SummaryInfo => {
+    // Calculate total projects
+    const totalProjects = projects.length;
+
+    // Count projects by category
+    const categories: Record<string, number> = {};
+    const subcategories: Record<string, number> = {};
+
+    // Collect dependencies
+    const dependenciesMap = new Map<
+        string,
+        { count: number; projects: string[] }
+    >();
+
+    // Calculate averages and find oldest/newest projects
+    let totalFileCount = 0;
+    let totalSize = 0;
+
+    // Process each project
+    projects.forEach((project) => {
+        // Update categories
+        categories[project.category] = (categories[project.category] || 0) + 1;
+        subcategories[project.subcategory] =
+            (subcategories[project.subcategory] || 0) + 1;
+
+        // Update dependencies
+        const allDeps = {
+            ...(project.packageJson.dependencies || {}),
+            ...(project.packageJson.devDependencies || {})
+        };
+
+        Object.keys(allDeps).forEach((dep) => {
+            const existing = dependenciesMap.get(dep) || {
+                count: 0,
+                projects: []
+            };
+            existing.count++;
+            existing.projects.push(project.path);
+            dependenciesMap.set(dep, existing);
+        });
+
+        // Update totals
+        totalFileCount += project.fileCount;
+        totalSize += project.size;
+    });
+
+    // Convert maps to arrays and sort by count
+    const dependencies = Array.from(dependenciesMap.entries())
+        .map(([name, data]) => ({
+            name,
+            count: data.count,
+            projects: data.projects
+        }))
+        .sort((a, b) => b.count - a.count);
+
+    // Calculate averages
+    const averageFileCount =
+        totalProjects > 0 ? totalFileCount / totalProjects : 0;
+    const averageSize = totalProjects > 0 ? totalSize / totalProjects : 0;
+
+    // Return summary
+    return {
+        totalProjects,
+        categories,
+        subcategories,
+        dependencies,
+        averageFileCount,
+        averageSize
+    };
+};
+
+/**
+ * Format bytes to a human-readable string
+ */
+const formatBytes = (bytes: number): string => {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+};
+
+/**
+ * Print summary in a readable format
+ */
+const printSummary = (summary: SummaryInfo): void => {
+    console.info('\n========== AZLE EXAMPLES SURVEY ==========\n');
+
+    console.info(`Total projects: ${summary.totalProjects}`);
+
+    console.info('\n---------- Projects by Category ----------');
+    Object.entries(summary.categories)
+        .sort((a, b) => b[1] - a[1])
+        .forEach(([category, count]) => {
+            console.info(`${category}: ${count} projects`);
+        });
+
+    console.info('\n---------- Projects by Subcategory ----------');
+    Object.entries(summary.subcategories)
+        .sort((a, b) => b[1] - a[1])
+        .forEach(([subcategory, count]) => {
+            console.info(`${subcategory}: ${count} projects`);
+        });
+
+    console.info('\n---------- Most Common Dependencies ----------');
+    summary.dependencies
+        .slice(0, 15) // Show top 15
+        .forEach((dep) => {
+            console.info(`${dep.name}: Used in ${dep.count} projects`);
+        });
+
+    console.info('\n---------- Size Statistics ----------');
+    console.info(
+        `Average file count: ${Math.round(summary.averageFileCount)} files per project`
+    );
+    console.info(`Average project size: ${formatBytes(summary.averageSize)}`);
+
+    console.info('\n=========================================\n');
+};
+
+// Main function
+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 survey Node.js projects in: ${startDirectory}`);
+
+    // Initialize projects array
+    const projects: ProjectInfo[] = [];
+
+    // Survey projects
+    await surveyProjects(startDirectory, projects);
+
+    // Generate summary
+    const summary = generateSummary(projects);
+
+    // Print summary
+    printSummary(summary);
+
+    // Write detailed results to a JSON file in the same directory as this script
+    const outputPath = path.join(scriptDir, 'examples-survey.json');
+    await fs.writeFile(
+        outputPath,
+        JSON.stringify(
+            {
+                summary,
+                projects
+            },
+            null,
+            2
+        )
+    );
+
+    console.info(`Detailed survey results written to: ${outputPath}`);
+}
+
+// Start the script
+main();

package/.scripts/tsx_migration/ts_node_to_tsx.js

@@ -0,0 +1,76 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Path to the package.json file
+const packageJsonPath = path.join(process.cwd(), 'package.json');
+
+// Helper function to sort an object by its keys
+const sortObjectByKeys = (obj) => {
+    return Object.keys(obj)
+        .sort()
+        .reduce((result, key) => {
+            result[key] = obj[key];
+            return result;
+        }, {});
+};
+
+// Read and parse package.json
+fs.readFile(packageJsonPath, 'utf8', (err, data) => {
+    if (err) {
+        console.error(`Error reading package.json file: ${err}`);
+        return;
+    }
+
+    let packageJson;
+    try {
+        packageJson = JSON.parse(data);
+    } catch (parseErr) {
+        console.error(`Error parsing package.json: ${parseErr}`);
+        return;
+    }
+
+    const tsxVersion = '^4.15.7';
+    let tsNodeRemoved = false;
+
+    // Check and update dependencies
+    if (packageJson.dependencies && packageJson.dependencies['ts-node']) {
+        delete packageJson.dependencies['ts-node'];
+        packageJson.dependencies['tsx'] = tsxVersion;
+        packageJson.dependencies = sortObjectByKeys(packageJson.dependencies);
+        tsNodeRemoved = true;
+    }
+
+    // Check and update devDependencies
+    if (packageJson.devDependencies && packageJson.devDependencies['ts-node']) {
+        delete packageJson.devDependencies['ts-node'];
+        packageJson.devDependencies['tsx'] = tsxVersion;
+        packageJson.devDependencies = sortObjectByKeys(
+            packageJson.devDependencies
+        );
+        tsNodeRemoved = true;
+    }
+
+    if (!tsNodeRemoved) {
+        console.info('ts-node not found in dependencies or devDependencies.');
+        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.');
+        }
+    );
+});

package/.scripts/update_candid.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Usage:
+# Start up your own replica on port 4943: dfx start --clean
+# cd examples
+# ../.scripts/update_candid.sh
+# cd motoko_examples
+# ../../.scripts/update_candid.sh
+
+upgrade_candid()
+{
+  npm install
+  npm link azle
+  dfx canister create --all
+  dfx build
+}
+
+upgrade_all()
+{
+
+for dir in */; do
+
+  # You can use this part to skip directories
+  # first_char=${dir:0:1}
+  # if [[ "$first_char" < "t" ]]; then
+  #     echo "Skipping directory: $dir"
+  #     continue
+  # fi
+
+  echo "Looking at directory: $dir"
+  if [ -f "$dir/dfx.json" ]; then
+    echo "Processing directory: $dir"
+    cd $dir
+    upgrade_candid
+    cd ..
+  fi
+done
+}
+
+upgrade_all

package/.scripts/update_dfx_json_main.js

@@ -0,0 +1,66 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Helper function to update the canister definition
+function updateCanister(canister) {
+    if (canister.root && canister.ts) {
+        canister.main = canister.ts;
+        delete canister.root;
+        delete canister.ts;
+    }
+    // Put 'main' right below 'type'
+    const { type, main, ...rest } = canister;
+    return { type, main, ...rest };
+}
+
+// Path to the examples directory
+const examplesDir = path.join(process.cwd(), 'examples');
+
+// Read all directories under examples/
+fs.readdir(examplesDir, { withFileTypes: true }, (err, entries) => {
+    if (err) {
+        console.error(`Error reading directory: ${err}`);
+        return;
+    }
+
+    // Filter to keep only directories
+    const directories = entries.filter((entry) => entry.isDirectory());
+
+    directories.forEach((dir) => {
+        const exampleName = dir.name;
+        const dfxFilePath = path.join(examplesDir, exampleName, 'dfx.json');
+
+        // Read dfx.json file
+        fs.readFile(dfxFilePath, 'utf8', (err, data) => {
+            if (err) {
+                console.error(`Error reading dfx.json: ${err}`);
+                return;
+            }
+
+            // Parse JSON
+            const json = JSON.parse(data);
+
+            // Update canisters
+            for (const canisterName in json.canisters) {
+                json.canisters[canisterName] = updateCanister(
+                    json.canisters[canisterName]
+                );
+            }
+
+            // Write updated dfx.json back to file
+            fs.writeFile(
+                dfxFilePath,
+                JSON.stringify(json, null, 2),
+                'utf8',
+                (err) => {
+                    if (err) {
+                        console.error(`Error writing updated dfx.json: ${err}`);
+                        return;
+                    }
+                    console.info(`Successfully updated ${dfxFilePath}`);
+                }
+            );
+        });
+    });
+});

package/.scripts/update_dfx_json_with_optimize.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+import json
+import os
+
+# Find all the dfx.json files in the current directory and its subdirectories
+for root, _, files in os.walk('.'):
+    for file in files:
+        if file == 'dfx.json':
+            file_path = os.path.join(root, file)
+            
+            # Load the JSON content from the file
+            with open(file_path, 'r') as json_file:
+                data = json.load(json_file)
+
+            # Iterate through the canisters and add "optimize": "size" after "wasm"
+            for canister in data['canisters'].values():
+                if 'wasm' in canister:
+                    canister['optimize'] = 'size'
+
+            # Write the updated JSON content back to the file
+            with open(file_path, 'w') as json_file:
+                json.dump(data, json_file, indent=4)