devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/index-627srx16.js

@@ -0,0 +1,45 @@
+// src/cli/package-metadata.ts
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+var packageMetadataPromise = null;
+async function loadPackageMetadata() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    try {
+      const packageJson = await readFile(packageJsonPath, "utf8");
+      const metadata = JSON.parse(packageJson);
+      if (metadata.name === "devflare") {
+        return metadata;
+      }
+    } catch {}
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not resolve the devflare package.json file");
+    }
+    currentDir = parentDir;
+  }
+}
+async function getPackageMetadata() {
+  if (!packageMetadataPromise) {
+    packageMetadataPromise = loadPackageMetadata();
+  }
+  return packageMetadataPromise;
+}
+async function getPackageVersion() {
+  return (await getPackageMetadata()).version ?? "0.0.0";
+}
+async function getInitDependencyVersions() {
+  const metadata = await getPackageMetadata();
+  const dependencies = metadata.dependencies ?? {};
+  const devDependencies = metadata.devDependencies ?? {};
+  return {
+    devflare: `^${metadata.version ?? "0.0.0"}`,
+    typescript: devDependencies.typescript ?? "^5.7.0",
+    wrangler: dependencies.wrangler ?? devDependencies.wrangler ?? "^4.85.0",
+    workersTypes: devDependencies["@cloudflare/workers-types"] ?? "^4.20250109.0"
+  };
+}
+
+export { getPackageVersion, getInitDependencyVersions };

package/dist/index-6bqgf5x8.js

@@ -0,0 +1,227 @@
+// src/shims/local-media-bindings.ts
+var LOCAL_MEDIA_BINDING_SCRIPT = `
+import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers'
+
+function emptyStream() {
+	return new ReadableStream({
+		start(controller) {
+			controller.close()
+		}
+	})
+}
+
+function normalizeContentType(value, fallback) {
+	if (typeof value !== 'string' || value.length === 0) return fallback
+	if (value.includes('/')) return value
+	if (value === 'jpg') return 'image/jpeg'
+	if (value === 'jpeg') return 'image/jpeg'
+	if (value === 'png') return 'image/png'
+	if (value === 'webp') return 'image/webp'
+	if (value === 'avif') return 'image/avif'
+	if (value === 'mp4') return 'video/mp4'
+	return value
+}
+
+async function readBytes(stream) {
+	return await new Response(stream || emptyStream()).arrayBuffer()
+}
+
+function streamFromBytes(bytes) {
+	return new Response(bytes.slice(0)).body || emptyStream()
+}
+
+function createBodyReader(bytes) {
+	return function takeBody() {
+		return streamFromBytes(bytes)
+	}
+}
+
+class LocalImageResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	contentType() {
+		return this.contentTypeValue
+	}
+
+	image() {
+		return this.takeBody()
+	}
+}
+
+class LocalImageTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return this
+	}
+
+	draw() {
+		return this
+	}
+
+	async output(options = {}) {
+		return new LocalImageResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'image/png')
+		)
+	}
+}
+
+function createHostedImagesBinding() {
+	const unsupported = () => {
+		throw new Error('Devflare local Images hosted API is not implemented. Use the transform/info APIs locally, or connect to Cloudflare for hosted image storage.')
+	}
+	return {
+		image() {
+			return {
+				details: unsupported,
+				bytes: unsupported,
+				update: unsupported,
+				delete: unsupported
+			}
+		},
+		upload: unsupported,
+		list: unsupported
+	}
+}
+
+export class LocalImagesBinding extends WorkerEntrypoint {
+	async info(stream) {
+		const bytes = await readBytes(stream)
+		return {
+			format: 'image/png',
+			fileSize: bytes.byteLength,
+			width: 1,
+			height: 1
+		}
+	}
+
+	async input(stream) {
+		return new LocalImageTransformer(await readBytes(stream))
+	}
+
+	get hosted() {
+		return createHostedImagesBinding()
+	}
+}
+
+class LocalMediaResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	async media() {
+		return this.takeBody()
+	}
+
+	async response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	async contentType() {
+		return this.contentTypeValue
+	}
+}
+
+class LocalMediaTransformationGenerator extends RpcTarget {
+	constructor(takeBody) {
+		super()
+		this.takeBody = takeBody
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+class LocalMediaTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return new LocalMediaTransformationGenerator(this.takeBody)
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+export class LocalMediaBinding extends WorkerEntrypoint {
+	async input(stream) {
+		return new LocalMediaTransformer(await readBytes(stream))
+	}
+}
+
+export default {
+	fetch() {
+		return new Response('Devflare local Images/Media binding')
+	}
+}
+`;
+function toLocalShimWorkerName(kind, bindingName, index) {
+  const slug = bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || kind;
+  return `devflare-local-${kind}-${index}-${slug}`;
+}
+function getEntrypoint(kind) {
+  return kind === "images" ? "LocalImagesBinding" : "LocalMediaBinding";
+}
+function buildLocalBindingShimServiceConfig(config) {
+  const entries = [
+    ...Object.keys(config.bindings?.images ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "images"
+    })),
+    ...Object.keys(config.bindings?.media ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "media"
+    }))
+  ];
+  return {
+    localBindingNames: entries.map((entry) => entry.bindingName),
+    serviceBindings: Object.fromEntries(entries.map((entry, index) => {
+      const workerName = toLocalShimWorkerName(entry.kind, entry.bindingName, index);
+      return [
+        entry.bindingName,
+        {
+          name: workerName,
+          entrypoint: getEntrypoint(entry.kind)
+        }
+      ];
+    })),
+    workers: entries.map((entry, index) => ({
+      name: toLocalShimWorkerName(entry.kind, entry.bindingName, index),
+      modules: true,
+      script: LOCAL_MEDIA_BINDING_SCRIPT,
+      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+      ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
+    }))
+  };
+}
+
+export { buildLocalBindingShimServiceConfig };