@ohos-ports/azle 0.33.0-beta.0

package/examples/stable/demo/hello_world/package.json

@@ -0,0 +1,14 @@
+{
+    "scripts": {
+        "pretest": "tsx test/pretest.ts",
+        "test": "jest"
+    },
+    "dependencies": {
+        "azle": "0.32.0"
+    },
+    "devDependencies": {
+        "cuzz": "^0.0.22",
+        "jest": "^30.0.4",
+        "ts-jest": "^29.4.0"
+    }
+}

package/examples/stable/demo/hello_world/src/index.ts

@@ -0,0 +1,15 @@
+import { IDL, query, update } from 'azle';
+
+export default class {
+    message: string = 'Hello world!';
+
+    @query([], IDL.Text)
+    getMessage(): string {
+        return this.message;
+    }
+
+    @update([IDL.Text])
+    setMessage(message: string): void {
+        this.message = message;
+    }
+}

package/examples/stable/demo/hello_world/test/pretest.ts

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process';
+
+function pretest(): void {
+    execSync(`dfx canister uninstall-code hello_world || true`, {
+        stdio: 'inherit'
+    });
+
+    execSync(`dfx deploy hello_world`, {
+        stdio: 'inherit'
+    });
+
+    execSync(`dfx generate hello_world`, {
+        stdio: 'inherit'
+    });
+}
+
+pretest();

package/examples/stable/demo/hello_world/test/test.ts

@@ -0,0 +1,15 @@
+import { getCanisterId } from 'azle/_internal/dfx';
+import { runTests } from 'azle/_internal/test';
+
+import { createActor } from './dfx_generated/hello_world';
+import { getTests } from './tests';
+
+const canisterName = 'hello_world';
+const helloWorldCanister = createActor(getCanisterId(canisterName), {
+    agentOptions: {
+        host: 'http://127.0.0.1:4943',
+        shouldFetchRootKey: true
+    }
+});
+
+runTests(getTests(helloWorldCanister));

package/examples/stable/demo/hello_world/test/tests.ts

@@ -0,0 +1,27 @@
+import { ActorSubclass } from '@dfinity/agent';
+import { expect, it, Test } from 'azle/_internal/test';
+
+import { _SERVICE } from './dfx_generated/hello_world/hello_world.did';
+
+export function getTests(helloWorldCanister: ActorSubclass<_SERVICE>): Test {
+    return () => {
+        it('gets original message', async () => {
+            const result = await helloWorldCanister.getMessage();
+
+            expect(result).toBe('Hello world!');
+        });
+
+        it('sets a new message', async () => {
+            const result =
+                await helloWorldCanister.setMessage('Goodbye world!');
+
+            expect(result).toBeUndefined();
+        });
+
+        it('gets persisted new message', async () => {
+            const result = await helloWorldCanister.getMessage();
+
+            expect(result).toBe('Goodbye world!');
+        });
+    };
+}

package/examples/stable/demo/hello_world/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "target": "ES2024",
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "allowJs": true,
+        "noEmit": true
+    }
+}

package/jest.config.dev.js

@@ -0,0 +1,10 @@
+export default {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testTimeout: 100_000_000,
+    transform: {
+        '^.+\\.ts$': ['ts-jest', { isolatedModules: true }],
+        '^.+\\.js$': 'ts-jest'
+    },
+    transformIgnorePatterns: ['/node_modules/(?!(azle|cuzz)/)'] // Make sure azle and cuzz are transformed
+};

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@ohos-ports/azle",
+  "version": "0.33.0-beta.0",
+  "description": "TypeScript and JavaScript CDK for the Internet Computer",
+  "scripts": {
+    "typecheck": "tsc",
+    "lint": "if [ \"$npm_config_fix\" ]; then eslint . --cache --fix; else eslint . --cache; fi",
+    "prepare": "husky",
+    "install": "cd src/stable/build/dfx_extension && ./install.sh",
+    "test": "echo 'test'",
+    "license-check": "licensee --errors-only && echo \"License check passed successfully!\" || { echo \"License check failed! Non-compliant licenses found.\"; exit 1; }"
+  },
+  "type": "module",
+  "bin": {
+    "azle": "./src/build.ts"
+  },
+  "exports": {
+    ".": "./src/stable/lib/index.ts",
+    "./_internal": "./src/exports/_internal.ts",
+    "./_internal/*": "./src/exports/_internal/*.ts",
+    "./canisters/*": "./src/exports/canisters/*.ts",
+    "./experimental": "./src/exports/experimental.ts",
+    "./experimental/*": "./src/exports/experimental/*.ts"
+  },
+  "imports": {
+    "#build/*": "./src/stable/build/*.ts",
+    "#commands/*": "./src/stable/build/commands/*.ts",
+    "#experimental/commands/*": "./src/experimental/build/commands/*.ts",
+    "#experimental/build/*": "./src/experimental/build/*.ts",
+    "#experimental/lib/*": "./src/experimental/lib/*.ts",
+    "#experimental/test/*": "./src/experimental/test/*.ts",
+    "#experimental/test/property/*": "./src/experimental/test/property/*.ts",
+    "#experimental/test/type/*": "./src/experimental/test/type/*.ts",
+    "#experimental/utils/*": "./src/experimental/build/utils/*.ts",
+    "#lib/*": "./src/stable/lib/*.ts",
+    "#test/*": "./src/stable/test/*.ts",
+    "#test/property/*": "./src/stable/test/property/*.ts",
+    "#test/type/*": "./src/stable/test/type/*.ts",
+    "#utils/*": "./src/stable/build/utils/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/azle/0.33.0"
+  },
+  "keywords": [],
+  "author": "AZLE token holders (nlhft-2iaaa-aaaae-qaaua-cai)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://github.com/demergent-labs/azle#readme",
+  "dependencies": {
+    "@dfinity/agent": "^3.2.1",
+    "@sinonjs/text-encoding": "0.7.3",
+    "binaryen": "^116.0.0",
+    "@ohos-ports/esbuild": "^0.28.1-beta.1",
+    "jssha": "^3.3.1",
+    "@ohos-ports/tsx": "^4.22.4-beta.4",
+    "typescript": "^5.9.2",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@dfinity/identity": "^3.2.1",
+    "@eslint/js": "^9.33.0",
+    "@types/semver": "^7.7.0",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.39.1",
+    "@typescript-eslint/parser": "^8.39.1",
+    "azle-experimental-deps": "github:demergent-labs/azle-experimental-deps#d520f28563b2d255c7edf5b672da6083fd722259",
+    "@ohos-ports/cuzz": "^0.0.23-beta.0",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "fast-check": "^4.2.0",
+    "husky": "9.1.7",
+    "jest": "^30.0.5",
+    "licensee": "^11.1.1",
+    "lint-staged": "16.1.5",
+    "prettier": "^3.6.2",
+    "@ohos-ports/puppeteer": "^25.6.0-beta.0",
+    "semver": "^7.7.2",
+    "ts-jest": "^29.4.1",
+    "@ohos-ports/typescript-eslint": "^8.65.0-beta.0"
+  },
+  "lint-staged": {
+    "*.{js,ts}": "eslint --cache --fix",
+    "**/*": "prettier --write --ignore-unknown"
+  },
+  "azle": {
+    "globalDependencies": {
+      "dfx": "0.28.0",
+      "node": "22.17.1",
+      "rust": "1.88.0",
+      "cargo-auditable": "0.7.0",
+      "cargo-audit": "https://github.com/rustsec/rustsec?rev=13604e1909456e25752784681f0367b13a21e47b#13604e19",
+      "cargo-bundle-licenses": "4.0.0",
+      "cargo-deny": "0.18.3",
+      "wasi2ic": "0.2.15"
+    }
+  }
+}

package/src/build.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env -S npx tsx
+
+import { getCanisterConfig } from '#utils/get_canister_config';
+import { Command, ExperimentalCommand } from '#utils/types';
+
+import { devDependencies } from '../package.json';
+
+process.on('uncaughtException', (error: Error) => {
+    const prefix = 'Azle BuildError';
+
+    const message =
+        process.env.AZLE_VERBOSE === 'true'
+            ? `${prefix}: ${error.stack}`
+            : `${prefix}: ${error}`;
+
+    console.error(message);
+
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (reason: any) => {
+    const prefix = 'Azle BuildError';
+
+    const message =
+        process.env.AZLE_VERBOSE === 'true' && reason instanceof Error
+            ? `${prefix}: ${reason.stack}`
+            : `${prefix}: ${reason}`;
+
+    console.error(message);
+
+    process.exit(1);
+});
+
+build();
+
+/**
+ * Determines if the build should use experimental features and calls the appropriate build function.
+ */
+async function build(): Promise<void> {
+    if (await isExperimental()) {
+        warnAboutExperimentalDeps();
+        globalThis._azleExperimental = true;
+        const { build } = await import('#experimental/build/index');
+        await build();
+    } else {
+        const { build } = await import('#build/index');
+        await build();
+    }
+}
+
+/**
+ * Determines if the current build should use experimental features.
+ * Checks canister config, command line arguments, and environment variables.
+ * @param canisterName The name of the canister being built.
+ * @returns A promise that resolves to true if the build is experimental, false otherwise.
+ */
+async function isExperimental(): Promise<boolean> {
+    const command = process.argv[2] as
+        | Command
+        | ExperimentalCommand
+        | undefined;
+
+    if (
+        command === 'dev' ||
+        command === 'extension' ||
+        command === 'generate' ||
+        command === 'new' ||
+        command === '--version'
+    ) {
+        return false;
+    }
+
+    if (process.env.AZLE_EXPERIMENTAL === 'true') {
+        return true;
+    }
+
+    if (
+        command === 'build' ||
+        command === 'post-install' ||
+        command === 'upload-assets'
+    ) {
+        const canisterName = process.argv[3];
+        const canisterConfig = await getCanisterConfig(canisterName);
+
+        return canisterConfig?.custom?.experimental === true;
+    }
+
+    return false;
+}
+
+function warnAboutExperimentalDeps(): void {
+    const azleExperimentalDepsVersionHash =
+        devDependencies['azle-experimental-deps'].split('#')[1];
+    console.warn(
+        `Azle Warning: Experimental mode requires azle-experimental-deps.`,
+        `If not yet installed, run \`npm install https://github.com/demergent-labs/azle-experimental-deps#${azleExperimentalDepsVersionHash}\``
+    );
+}

package/src/experimental/build/assert_experimental.ts

@@ -0,0 +1,5 @@
+if (globalThis._azleExperimental !== true) {
+    throw new Error(
+        'Azle: experimental mode must be enabled to import from azle/experimental or #experimental. You can enable experimental mode by setting AZLE_EXPERIMENTAL to true in your environment.'
+    );
+}

package/src/experimental/build/commands/build/candid_and_method_meta.ts

@@ -0,0 +1,30 @@
+import '#experimental/build/assert_experimental';
+
+import { IOType } from 'child_process';
+import { readFile } from 'fs/promises';
+
+import { execute } from '#commands/build/candid_and_method_meta/execute';
+import { WasmData } from '#experimental/utils/types';
+import { CandidAndMethodMeta, CandidGen } from '#utils/types';
+
+import { getWasmBinary } from './wasm_binary';
+
+export async function getCandidAndMethodMeta(
+    candidGen: CandidGen | undefined,
+    candidPath: string,
+    js: string,
+    ioType: IOType,
+    wasmData: WasmData
+): Promise<CandidAndMethodMeta> {
+    const wasmBinary = await getWasmBinary(ioType, js, wasmData);
+
+    const { candid, methodMeta } = await execute(wasmBinary);
+
+    return {
+        candid:
+            candidGen === 'custom'
+                ? (await readFile(candidPath)).toString()
+                : candid,
+        methodMeta
+    };
+}

package/src/experimental/build/commands/build/custom_js_modules/acorn/acorn.ts

@@ -0,0 +1,6 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is just a placeholder module so that bundling won't break
+// TODO eventually we would want a real implementation of this in Azle or wasmedge-quickjs or Waden
+
+export {};

package/src/experimental/build/commands/build/custom_js_modules/acorn/walk.ts

@@ -0,0 +1,6 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is just a placeholder module so that bundling won't break
+// TODO eventually we would want a real implementation of this in Azle or wasmedge-quickjs or Waden
+
+export {};

package/src/experimental/build/commands/build/custom_js_modules/async_hooks.ts

@@ -0,0 +1,11 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is just a placeholder module so that bundling won't break
+// TODO eventually we would want a real implementation of this in Azle or wasmedge-quickjs or Waden
+// TODO it seems async_hooks is impossible or very difficult to polyfill in the browser
+// TODO I am not sure what it would take to do it in Wasm/QuickJS
+// TODO It might be a bit tricky
+// TODO We might be able to PR into NestJS and get rid of their dependency on this (turns out they check if asyncHooks.AsyncResource is defined)
+// TODO as Node.js does not recommend its use
+
+export {};

package/src/experimental/build/commands/build/custom_js_modules/https.ts

@@ -0,0 +1,6 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is just a placeholder module so that bundling won't break
+// TODO eventually we would want a real implementation of this in Azle or wasmedge-quickjs or Waden
+
+export {};

package/src/experimental/build/commands/build/custom_js_modules/perf_hooks.ts

@@ -0,0 +1,12 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO this is just a placeholder module so that bundling won't break
+// TODO eventually we would want a real implementation of this in Azle or wasmedge-quickjs or Waden
+// TODO we should PR this implementation into https://github.com/WasmEdge/WasmEdge/issues/1535
+// TODO it should be pretty easy and a good way to get started in the repo
+
+const performance = {
+    now: (): number => new Date().getTime()
+};
+
+export { performance };

package/src/experimental/build/commands/build/file_watcher/file_watcher.ts

@@ -0,0 +1,152 @@
+import '#experimental/build/assert_experimental';
+
+import { Actor, ActorMethod, ActorSubclass } from '@dfinity/agent';
+import { watch } from 'chokidar';
+import { mkdir, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+
+import { createAuthenticatedAgent } from '#experimental/utils/dfx';
+
+import { generateUploaderIdentity } from '../../upload_assets/uploader_identity';
+import { compile as compileJavaScript } from '../javascript';
+
+type ActorReloadJs = ActorSubclass<_SERVICE>;
+interface _SERVICE {
+    _azle_reload_js: ActorMethod<
+        [bigint, bigint, Uint8Array, bigint, number],
+        void
+    >;
+}
+
+// We have made this mutable to help with speed
+// We don't want to have to create the agent on each file change
+let actor: ActorReloadJs | undefined;
+
+const reloadedJsPath = process.argv[2];
+const canisterId = process.argv[3];
+const mainPath = process.argv[4];
+const esmAliases = JSON.parse(process.argv[5]);
+const esmExternals = JSON.parse(process.argv[6]);
+const canisterName = process.argv[7];
+const postUpgradeIndex = Number(process.argv[8]);
+
+// TODO https://github.com/demergent-labs/azle/issues/1664
+const watcher = watch('.', {
+    ignored: (path, stats) => {
+        if (
+            path.includes('.dfx') === true ||
+            path.includes('.azle') === true ||
+            path.includes('node_modules') === true ||
+            path.includes('target') === true
+        ) {
+            return true;
+        }
+
+        if (stats?.isFile() === true) {
+            return (
+                path.endsWith('.ts') === false && path.endsWith('.js') === false
+            );
+        }
+
+        return false;
+    }
+});
+
+watcher.on('all', async (event, path) => {
+    if (actor === undefined) {
+        actor = await createActorReloadJs(canisterName);
+    }
+
+    if (process.env.AZLE_VERBOSE === 'true') {
+        console.info('event', event);
+        console.info('path', path);
+    }
+
+    if (event === 'change' || event === 'add') {
+        try {
+            await reloadJs(actor, reloadedJsPath, mainPath);
+        } catch (error) {
+            console.error(error);
+        }
+    }
+});
+
+async function reloadJs(
+    actor: ActorReloadJs,
+    reloadedJsPath: string,
+    mainPath: string
+): Promise<void> {
+    const javaScript = await compileJavaScript(
+        mainPath,
+        esmAliases,
+        esmExternals
+    );
+
+    const reloadedJs = Buffer.from(javaScript);
+
+    const chunkSize = 2_000_000; // The current message limit is about 2 MiB
+    const timestamp = process.hrtime.bigint();
+    let chunkNumber = 0n;
+
+    for (let i = 0; i < reloadedJs.length; i += chunkSize) {
+        const chunk = reloadedJs.slice(i, i + chunkSize);
+
+        if (process.env.AZLE_VERBOSE === 'true') {
+            console.info(
+                `Uploading chunk: ${timestamp}, ${chunkNumber}, ${chunk.length}, ${reloadedJs.length}`
+            );
+        }
+
+        actor
+            ._azle_reload_js(
+                timestamp,
+                chunkNumber,
+                chunk,
+                BigInt(reloadedJs.length),
+                postUpgradeIndex
+            )
+            .catch((error) => {
+                if (process.env.AZLE_VERBOSE === 'true') {
+                    console.error(error);
+                }
+            });
+
+        chunkNumber += 1n;
+    }
+
+    if (process.env.AZLE_VERBOSE === 'true') {
+        console.info(`Finished uploading chunks`);
+    }
+
+    await mkdir(dirname(reloadedJsPath), { recursive: true });
+    await writeFile(reloadedJsPath, reloadedJs);
+}
+
+async function createActorReloadJs(
+    canisterName: string
+): Promise<ActorReloadJs> {
+    const identityName = generateUploaderIdentity(canisterName);
+    const agent = await createAuthenticatedAgent(identityName);
+
+    return Actor.createActor(
+        ({ IDL }) => {
+            return IDL.Service({
+                _azle_reload_js: IDL.Func(
+                    [
+                        IDL.Nat64,
+                        IDL.Nat64,
+                        IDL.Vec(IDL.Nat8),
+                        IDL.Nat64,
+                        IDL.Int32
+                    ],
+                    [],
+                    []
+                )
+            });
+        },
+        {
+            agent,
+            canisterId
+        }
+    );
+}

package/src/experimental/build/commands/build/file_watcher/file_watcher_loader.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+if (process.env.AZLE_EXPERIMENTAL !== 'true') {
+    throw new Error(
+        'Azle: experimental mode must be enabled to import from azle/experimental or #experimental. You can enable experimental mode by setting AZLE_EXPERIMENTAL to true in your environment.'
+    );
+}
+
+import 'tsx';
+import('./file_watcher.js');

package/src/experimental/build/commands/build/file_watcher/setup_file_watcher.ts

@@ -0,0 +1,61 @@
+import '#experimental/build/assert_experimental';
+
+import { spawn } from 'child_process';
+import { join } from 'path';
+
+import { execSyncPretty } from '#utils/exec_sync_pretty';
+import { AZLE_ROOT } from '#utils/global_paths';
+
+export function setupFileWatcher(
+    reloadedJsPath: string,
+    canisterId: string,
+    mainPath: string,
+    esmAliases: Record<string, string>,
+    esmExternals: string[],
+    canisterName: string,
+    postUpgradeIndex: number
+): void {
+    try {
+        // TODO should we check that this was successful in killing
+        // TODO the process and then warn the user if not?
+        // TODO should we figure out why the || true
+        // TODO does not result in a 0 exit code
+        // TODO and look into removing the try catch?
+        execSyncPretty(`pkill -f ./file_watcher_loader.js || true`);
+    } catch {
+        // For some reason pkill throws even with || true
+    }
+
+    if (process.env.AZLE_AUTORELOAD !== 'true') {
+        return;
+    }
+
+    const watcherProcess = spawn(
+        'node',
+        [
+            join(
+                AZLE_ROOT,
+                'src',
+                'experimental',
+                'build',
+                'commands',
+                'build',
+                'file_watcher',
+                'file_watcher_loader.js'
+            ),
+            reloadedJsPath,
+            canisterId,
+            mainPath,
+            JSON.stringify(esmAliases),
+            JSON.stringify(esmExternals),
+            canisterName,
+            postUpgradeIndex.toString()
+        ],
+        {
+            detached: true,
+            stdio: 'inherit'
+        }
+    );
+
+    watcherProcess.unref();
+}