devflare 1.0.0-next.34 → 1.0.0-next.36

package/dist/index-dm9q84c7.js

@@ -1,360 +0,0 @@
-// src/shims/local-media-bindings.ts
-function emptyNodeStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function normalizeNodeContentType(value, fallback) {
-  if (!value)
-    return fallback;
-  if (value.includes("/"))
-    return value;
-  if (value === "jpg" || 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 readNodeBytes(stream) {
-  const buffer = await new Response(stream ?? emptyNodeStream()).arrayBuffer();
-  return new Uint8Array(buffer);
-}
-function streamFromNodeBytes(bytes) {
-  const copy = new Uint8Array(bytes.byteLength);
-  copy.set(bytes);
-  return new Response(copy).body ?? emptyNodeStream();
-}
-function createUnsupportedHostedImagesBinding() {
-  const unsupported = () => {
-    throw new Error("Devflare local Images hosted API is not implemented. Use transform/info APIs locally, or connect to Cloudflare for hosted image storage.");
-  };
-  return {
-    image(_imageId) {
-      return {
-        details: unsupported,
-        bytes: unsupported,
-        update: unsupported,
-        delete: unsupported
-      };
-    },
-    upload: unsupported,
-    list: unsupported
-  };
-}
-function createNodeImageResult(bytes, contentType) {
-  return {
-    response() {
-      return new Response(streamFromNodeBytes(bytes), {
-        headers: { "Content-Type": contentType }
-      });
-    },
-    contentType() {
-      return contentType;
-    },
-    image() {
-      return streamFromNodeBytes(bytes);
-    }
-  };
-}
-function createNodeImageTransformer(bytesPromise) {
-  const transformer = {
-    transform(_transform) {
-      return transformer;
-    },
-    draw(_image, _options) {
-      return transformer;
-    },
-    async output(options) {
-      return createNodeImageResult(await bytesPromise, normalizeNodeContentType(options?.format, "image/png"));
-    }
-  };
-  return transformer;
-}
-function createLocalImagesBinding() {
-  return {
-    async info(stream) {
-      const bytes = await readNodeBytes(stream);
-      return {
-        format: "image/png",
-        fileSize: bytes.byteLength,
-        width: 1,
-        height: 1
-      };
-    },
-    input(stream) {
-      return createNodeImageTransformer(readNodeBytes(stream));
-    },
-    hosted: createUnsupportedHostedImagesBinding()
-  };
-}
-function createNodeMediaResult(bytesPromise, contentType) {
-  return {
-    async media() {
-      return streamFromNodeBytes(await bytesPromise);
-    },
-    async response() {
-      return new Response(streamFromNodeBytes(await bytesPromise), {
-        headers: { "Content-Type": contentType }
-      });
-    },
-    async contentType() {
-      return contentType;
-    }
-  };
-}
-function createNodeMediaTransformer(bytesPromise) {
-  const output = (options = {}) => createNodeMediaResult(bytesPromise, normalizeNodeContentType(options.format, "video/mp4"));
-  return {
-    transform(_transform) {
-      return {
-        output(options) {
-          return output(options);
-        }
-      };
-    },
-    output(options) {
-      return output(options);
-    }
-  };
-}
-function createLocalMediaBinding() {
-  return {
-    input(stream) {
-      return createNodeMediaTransformer(readNodeBytes(stream));
-    }
-  };
-}
-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 { createLocalImagesBinding, createLocalMediaBinding, buildLocalBindingShimServiceConfig };

package/dist/index-pmnb7eke.js

@@ -1,109 +0,0 @@
-import {
-  bundleWorkerEntry
-} from "./index-dem45895.js";
-import {
-  DEFAULT_WORKFLOW_PATTERN,
-  findFiles
-} from "./index-5dkjffqz.js";
-import {
-  normalizeWorkflowBinding
-} from "./index-pd97hk2j.js";
-
-// src/workflows/local-workflow-entrypoints.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, relative, resolve } from "pathe";
-function findExportedClasses(code) {
-  const classes = [];
-  const classPattern = /export\s+class\s+(\w+)/g;
-  let match;
-  while ((match = classPattern.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-function toImportSpecifier(fromDir, filePath) {
-  const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-async function discoverWorkflowClasses(config, configDir) {
-  const classToFilePath = new Map;
-  const workflowPatternConfig = config.files?.workflows;
-  const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
-  if (workflowPatternConfig === false) {
-    return classToFilePath;
-  }
-  const files = await findFiles(workflowPattern, { cwd: configDir });
-  for (const filePath of files) {
-    try {
-      const code = await readFile(filePath, "utf-8");
-      for (const className of findExportedClasses(code)) {
-        classToFilePath.set(className, filePath);
-      }
-    } catch {}
-  }
-  return classToFilePath;
-}
-async function resolveLocalWorkflowEntrypoints(config, configDir) {
-  const workflows = config.bindings?.workflows;
-  if (!workflows || Object.keys(workflows).length === 0) {
-    return [];
-  }
-  const classToFilePath = await discoverWorkflowClasses(config, configDir);
-  const entrypoints = [];
-  for (const [bindingName, binding] of Object.entries(workflows)) {
-    const normalized = normalizeWorkflowBinding(binding);
-    if (normalized.scriptName) {
-      continue;
-    }
-    const scriptPath = classToFilePath.get(normalized.className);
-    if (!scriptPath) {
-      throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.
-` + `Either set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
-    }
-    entrypoints.push({
-      bindingName,
-      className: normalized.className,
-      scriptPath
-    });
-  }
-  return entrypoints;
-}
-function buildWorkflowVirtualEntry(entrypoints, entryDir) {
-  const imports = entrypoints.map((entrypoint, index) => {
-    const importName = `__DevflareWorkflow${index}`;
-    const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
-    return {
-      importName,
-      className: entrypoint.className,
-      line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
-    };
-  });
-  const exports = imports.map((entrypoint) => {
-    return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
-  });
-  return [...imports.map((entrypoint) => entrypoint.line), "", ...exports].join(`
-`);
-}
-async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
-  const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
-  if (entrypoints.length === 0) {
-    return "";
-  }
-  const entryDir = resolve(configDir, ".devflare", "workflow-entrypoints");
-  const entryPath = join(entryDir, "__entry.ts");
-  const outFile = join(entryDir, "index.js");
-  await mkdir(entryDir, { recursive: true });
-  await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
-  await bundleWorkerEntry({
-    cwd: configDir,
-    inputFile: entryPath,
-    outFile,
-    rolldownOptions: config.rolldown?.options,
-    sourcemap: config.rolldown?.sourcemap,
-    minify: config.rolldown?.minify,
-    logger: options.logger
-  });
-  return await readFile(outFile, "utf-8");
-}
-
-export { bundleWorkflowEntrypointScript };

package/dist/index-t23wq5js.js

@@ -1,111 +0,0 @@
-import {
-  bridgeEnv,
-  getContextOrNull
-} from "./index-1trss579.js";
-
-// src/env.ts
-var testContextEnv = null;
-var testContextDispose = null;
-function __setTestContext(envBindings, dispose) {
-  testContextEnv = envBindings;
-  testContextDispose = dispose;
-}
-function __clearTestContext() {
-  testContextEnv = null;
-  testContextDispose = null;
-}
-var env = new Proxy({}, {
-  get(_target, prop) {
-    if (prop === "dispose") {
-      return async () => {
-        if (testContextDispose) {
-          await testContextDispose();
-          __clearTestContext();
-        }
-      };
-    }
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return ctx.env[prop];
-    }
-    if (testContextEnv) {
-      return testContextEnv[prop];
-    }
-    return bridgeEnv[prop];
-  },
-  has(_target, prop) {
-    if (prop === "dispose")
-      return true;
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return prop in ctx.env;
-    }
-    if (testContextEnv) {
-      return prop in testContextEnv;
-    }
-    return prop in bridgeEnv;
-  },
-  ownKeys(_target) {
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return Reflect.ownKeys(ctx.env);
-    }
-    if (testContextEnv) {
-      return Reflect.ownKeys(testContextEnv);
-    }
-    return Reflect.ownKeys(bridgeEnv);
-  },
-  getOwnPropertyDescriptor(_target, prop) {
-    if (prop === "dispose") {
-      return { configurable: true, enumerable: false, writable: false };
-    }
-    const ctx = getContextOrNull();
-    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
-    return Reflect.getOwnPropertyDescriptor(source, prop);
-  }
-});
-var vars = new Proxy({}, {
-  get(_target, prop) {
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return ctx.env[prop];
-    }
-    if (testContextEnv) {
-      return testContextEnv[prop];
-    }
-    return bridgeEnv[prop];
-  },
-  has(_target, prop) {
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return prop in ctx.env;
-    }
-    if (testContextEnv) {
-      return prop in testContextEnv;
-    }
-    return prop in bridgeEnv;
-  },
-  ownKeys(_target) {
-    const ctx = getContextOrNull();
-    if (ctx?.env) {
-      return Reflect.ownKeys(ctx.env);
-    }
-    if (testContextEnv) {
-      return Reflect.ownKeys(testContextEnv);
-    }
-    return Reflect.ownKeys(bridgeEnv);
-  },
-  getOwnPropertyDescriptor(_target, prop) {
-    const ctx = getContextOrNull();
-    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
-    return Reflect.getOwnPropertyDescriptor(source, prop);
-  },
-  set(_target, prop) {
-    throw new TypeError(`Cannot assign to '${String(prop)}' on 'vars' because it is read-only.`);
-  },
-  deleteProperty(_target, prop) {
-    throw new TypeError(`Cannot delete property '${String(prop)}' from 'vars' because it is read-only.`);
-  }
-});
-
-export { __setTestContext, __clearTestContext, env, vars };