@astrojs/cloudflare 0.0.0-cf-assets-20231021193132

package/dist/utils/parser.js

@@ -0,0 +1,149 @@
+/**
+ * This file is a derivative work of wrangler by Cloudflare
+ * An upstream request for exposing this API was made here:
+ * https://github.com/cloudflare/workers-sdk/issues/3897
+ *
+ * Until further notice, we will be using this file as a workaround
+ * TODO: Tackle this file, once their is an decision on the upstream request
+ */
+import TOML from '@iarna/toml';
+import dotenv from 'dotenv';
+import { findUpSync } from 'find-up';
+import * as fs from 'node:fs';
+import { dirname, resolve } from 'node:path';
+let _wrangler;
+function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
+    if (preferJson) {
+        return (findUpSync(`wrangler.json`, { cwd: referencePath }) ??
+            findUpSync(`wrangler.toml`, { cwd: referencePath }));
+    }
+    return findUpSync(`wrangler.toml`, { cwd: referencePath });
+}
+class ParseError extends Error {
+    text;
+    notes;
+    location;
+    kind;
+    constructor({ text, notes, location, kind }) {
+        super(text);
+        this.name = this.constructor.name;
+        this.text = text;
+        this.notes = notes ?? [];
+        this.location = location;
+        this.kind = kind ?? 'error';
+    }
+}
+const TOML_ERROR_NAME = 'TomlError';
+const TOML_ERROR_SUFFIX = ' at row ';
+function parseTOML(input, file) {
+    try {
+        // Normalize CRLF to LF to avoid hitting https://github.com/iarna/iarna-toml/issues/33.
+        const normalizedInput = input.replace(/\r\n/g, '\n');
+        return TOML.parse(normalizedInput);
+    }
+    catch (err) {
+        const { name, message, line, col } = err;
+        if (name !== TOML_ERROR_NAME) {
+            throw err;
+        }
+        const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+        const lineText = input.split('\n')[line];
+        const location = {
+            lineText,
+            line: line + 1,
+            column: col - 1,
+            file,
+            fileText: input,
+        };
+        throw new ParseError({ text, location });
+    }
+}
+function tryLoadDotEnv(path) {
+    try {
+        const parsed = dotenv.parse(fs.readFileSync(path));
+        return { path, parsed };
+    }
+    catch (e) {
+        // logger.debug(`Failed to load .env file "${path}":`, e);
+    }
+}
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export function loadDotEnv(path) {
+    return tryLoadDotEnv(path);
+}
+function getVarsForDev(config, configPath) {
+    const configDir = resolve(dirname(configPath ?? '.'));
+    const devVarsPath = resolve(configDir, '.dev.vars');
+    const loaded = loadDotEnv(devVarsPath);
+    if (loaded !== undefined) {
+        return {
+            ...config.vars,
+            ...loaded.parsed,
+        };
+    }
+    else {
+        return config.vars;
+    }
+}
+function parseConfig() {
+    if (_wrangler)
+        return _wrangler;
+    let rawConfig;
+    const configPath = findWranglerToml(process.cwd(), false); // false = args.experimentalJsonConfig
+    if (!configPath) {
+        throw new Error('Could not find wrangler.toml');
+    }
+    // Load the configuration from disk if available
+    if (configPath?.endsWith('toml')) {
+        rawConfig = parseTOML(fs.readFileSync(configPath).toString(), configPath);
+    }
+    _wrangler = { rawConfig, configPath };
+    return { rawConfig, configPath };
+}
+export async function getEnvVars() {
+    const { rawConfig, configPath } = parseConfig();
+    const vars = getVarsForDev(rawConfig, configPath);
+    return vars;
+}
+export async function getD1Bindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.d1_databases)
+        return [];
+    const bindings = (rawConfig?.d1_databases).map((binding) => binding.binding);
+    return bindings;
+}
+export async function getR2Bindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.r2_buckets)
+        return [];
+    const bindings = (rawConfig?.r2_buckets).map((binding) => binding.binding);
+    return bindings;
+}
+export async function getKVBindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return [];
+    if (!rawConfig?.kv_namespaces)
+        return [];
+    const bindings = (rawConfig?.kv_namespaces).map((binding) => binding.binding);
+    return bindings;
+}
+export function getDOBindings() {
+    const { rawConfig } = parseConfig();
+    if (!rawConfig)
+        return {};
+    if (!rawConfig?.durable_objects)
+        return {};
+    const output = new Object({});
+    for (const binding of rawConfig?.durable_objects.bindings) {
+        Reflect.set(output, binding.name, { className: binding.class_name });
+    }
+    return output;
+}

package/dist/utils/prependForwardSlash.d.ts

@@ -0,0 +1 @@
+export declare function prependForwardSlash(path: string): string;

package/dist/utils/prependForwardSlash.js

@@ -0,0 +1,3 @@
+export function prependForwardSlash(path) {
+    return path[0] === '/' ? path : '/' + path;
+}

package/dist/utils/rewriteWasmImportPath.d.ts

@@ -0,0 +1,8 @@
+import esbuild from 'esbuild';
+/**
+ *
+ * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.
+ */
+export declare function rewriteWasmImportPath({ relativePathToAssets, }: {
+    relativePathToAssets: string;
+}): esbuild.Plugin;

package/dist/utils/rewriteWasmImportPath.js

@@ -0,0 +1,23 @@
+import esbuild from 'esbuild';
+import { basename } from 'node:path';
+/**
+ *
+ * @param relativePathToAssets - relative path from the final location for the current esbuild output bundle, to the assets directory.
+ */
+export function rewriteWasmImportPath({ relativePathToAssets, }) {
+    return {
+        name: 'wasm-loader',
+        setup(build) {
+            build.onResolve({ filter: /.*\.wasm.mjs$/ }, (args) => {
+                const updatedPath = [
+                    relativePathToAssets.replaceAll('\\', '/'),
+                    basename(args.path).replace(/\.mjs$/, ''),
+                ].join('/');
+                return {
+                    path: updatedPath,
+                    external: true, // mark it as external in the bundle
+                };
+            });
+        },
+    };
+}

package/dist/utils/wasm-module-loader.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from 'vite';
+/**
+ * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+ * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+ * Cloudflare worker WASM from javascript support: https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/
+ * @param disabled - if true throws a helpful error message if wasm is encountered and wasm imports are not enabled,
+ * 								otherwise it will error obscurely in the esbuild and vite builds
+ * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
+ * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
+ */
+export declare function wasmModuleLoader({ disabled, assetsDirectory, }: {
+    disabled: boolean;
+    assetsDirectory: string;
+}): Plugin;

package/dist/utils/wasm-module-loader.js

@@ -0,0 +1,101 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {} from 'vite';
+/**
+ * Loads '*.wasm?module' imports as WebAssembly modules, which is the only way to load WASM in cloudflare workers.
+ * Current proposal for WASM modules: https://github.com/WebAssembly/esm-integration/tree/main/proposals/esm-integration
+ * Cloudflare worker WASM from javascript support: https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/
+ * @param disabled - if true throws a helpful error message if wasm is encountered and wasm imports are not enabled,
+ * 								otherwise it will error obscurely in the esbuild and vite builds
+ * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
+ * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
+ */
+export function wasmModuleLoader({ disabled, assetsDirectory, }) {
+    const postfix = '.wasm?module';
+    let isDev = false;
+    return {
+        name: 'vite:wasm-module-loader',
+        enforce: 'pre',
+        configResolved(config) {
+            isDev = config.command === 'serve';
+        },
+        config(_, __) {
+            // let vite know that file format and the magic import string is intentional, and will be handled in this plugin
+            return {
+                assetsInclude: ['**/*.wasm?module'],
+                build: { rollupOptions: { external: /^__WASM_ASSET__.+\.wasm\.mjs$/i } },
+            };
+        },
+        load(id, _) {
+            if (!id.endsWith(postfix)) {
+                return;
+            }
+            if (disabled) {
+                throw new Error(`WASM module's cannot be loaded unless you add \`wasmModuleImports: true\` to your astro config.`);
+            }
+            const filePath = id.slice(0, -1 * '?module'.length);
+            const data = fs.readFileSync(filePath);
+            const base64 = data.toString('base64');
+            const base64Module = `
+const wasmModule = new WebAssembly.Module(Uint8Array.from(atob("${base64}"), c => c.charCodeAt(0)));
+export default wasmModule
+`;
+            if (isDev) {
+                // no need to wire up the assets in dev mode, just rewrite
+                return base64Module;
+            }
+            else {
+                // just some shared ID
+                let hash = hashString(base64);
+                // emit the wasm binary as an asset file, to be picked up later by the esbuild bundle for the worker.
+                // give it a shared deterministic name to make things easy for esbuild to switch on later
+                const assetName = path.basename(filePath).split('.')[0] + '.' + hash + '.wasm';
+                this.emitFile({
+                    type: 'asset',
+                    // put it explicitly in the _astro assets directory with `fileName` rather than `name` so that
+                    // vite doesn't give it a random id in its name. We need to be able to easily rewrite from
+                    // the .mjs loader and the actual wasm asset later in the ESbuild for the worker
+                    fileName: path.join(assetsDirectory, assetName),
+                    source: fs.readFileSync(filePath),
+                });
+                // however, by default, the SSG generator cannot import the .wasm as a module, so embed as a base64 string
+                const chunkId = this.emitFile({
+                    type: 'prebuilt-chunk',
+                    fileName: assetName + '.mjs',
+                    code: base64Module,
+                });
+                return `
+import wasmModule from "__WASM_ASSET__${chunkId}.wasm.mjs";
+export default wasmModule;
+	`;
+            }
+        },
+        // output original wasm file relative to the chunk
+        renderChunk(code, chunk, _) {
+            if (isDev)
+                return;
+            if (!/__WASM_ASSET__/g.test(code))
+                return;
+            const final = code.replaceAll(/__WASM_ASSET__([a-z\d]+).wasm.mjs/g, (s, assetId) => {
+                const fileName = this.getFileName(assetId);
+                const relativePath = path
+                    .relative(path.dirname(chunk.fileName), fileName)
+                    .replaceAll('\\', '/'); // fix windows paths for import
+                return `./${relativePath}`;
+            });
+            return { code: final };
+        },
+    };
+}
+/**
+ * Returns a deterministic 32 bit hash code from a string
+ */
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash &= hash; // Convert to 32bit integer
+    }
+    return new Uint32Array([hash])[0].toString(36);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "//comment": "test changeset-bot",
+  "name": "@astrojs/cloudflare",
+  "description": "Deploy your site to Cloudflare Workers/Pages",
+  "version": "0.0.0-cf-assets-20231021193132",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "withastro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/withastro/adapters.git",
+    "directory": "packages/cloudflare"
+  },
+  "keywords": [
+    "withastro",
+    "astro-adapter"
+  ],
+  "bugs": "https://github.com/withastro/adapters/issues",
+  "homepage": "https://docs.astro.build/en/guides/integrations-guide/cloudflare/",
+  "exports": {
+    ".": "./dist/index.js",
+    "./entrypoints/server.advanced.js": "./dist/entrypoints/server.advanced.js",
+    "./entrypoints/server.directory.js": "./dist/entrypoints/server.directory.js",
+    "./image-service": "./dist/entrypoints/image-service.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@astrojs/underscore-redirects": "^0.3.0",
+    "@cloudflare/workers-types": "^4.20230821.0",
+    "miniflare": "3.20231010.0",
+    "@iarna/toml": "^2.2.5",
+    "dotenv": "^16.3.1",
+    "esbuild": "^0.19.2",
+    "find-up": "^6.3.0",
+    "tiny-glob": "^0.2.9",
+    "vite": "^4.4.9"
+  },
+  "peerDependencies": {
+    "astro": "^3.3.0"
+  },
+  "devDependencies": {
+    "execa": "^8.0.1",
+    "fast-glob": "^3.3.1",
+    "@types/iarna__toml": "^2.0.2",
+    "strip-ansi": "^7.1.0",
+    "astro": "^3.2.3",
+    "chai": "^4.3.7",
+    "cheerio": "1.0.0-rc.12",
+    "mocha": "^10.2.0",
+    "wrangler": "^3.11.0",
+    "@astrojs/test-utils": "0.0.1"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "mocha --exit --timeout 30000 test/",
+    "test:match": "mocha --exit --timeout 30000 -g"
+  }
+}