@ecopages/core 0.2.0-alpha.1

package/src/utils/css.ts

@@ -0,0 +1,5 @@
+export const css = async (strings: TemplateStringsArray, ...values: any[]): Promise<string> => {
+	const css = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
+	// return await PostCssProcessor.processStringOrBuffer(css);
+	return css;
+};

package/src/utils/deep-merge.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This module contains a simple utility function to merge two objects deeply
+ * @module
+ */
+/**
+ * Deeply merges two objects or arrays
+ * @function deepMerge
+ * @template T - Type of target object
+ * @template U - Type of source object
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns A new object with merged properties
+ */
+export declare function deepMerge<T, U>(target: T, source: U): T & U;

package/src/utils/deep-merge.js

@@ -0,0 +1,32 @@
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function isArray(item) {
+  return Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (isArray(target) && isArray(source)) {
+    return [...target, ...source];
+  }
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+  const output = Object.assign({}, target);
+  for (const key in source) {
+    if (isObject(source[key])) {
+      if (!target[key]) {
+        Object.assign(output, { [key]: source[key] });
+      } else {
+        output[key] = deepMerge(target[key], source[key]);
+      }
+    } else if (isArray(source[key])) {
+      output[key] = [...target[key] || [], ...source[key]];
+    } else if (source[key] !== void 0) {
+      Object.assign(output, { [key]: source[key] });
+    }
+  }
+  return output;
+}
+export {
+  deepMerge
+};

package/src/utils/deep-merge.ts

@@ -0,0 +1,47 @@
+/**
+ * This module contains a simple utility function to merge two objects deeply
+ * @module
+ */
+
+function isObject(item: any): item is Record<string, unknown> {
+	return item && typeof item === 'object' && !Array.isArray(item);
+}
+
+function isArray(item: any): item is unknown[] {
+	return Array.isArray(item);
+}
+
+/**
+ * Deeply merges two objects or arrays
+ * @function deepMerge
+ * @template T - Type of target object
+ * @template U - Type of source object
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns A new object with merged properties
+ */
+export function deepMerge<T, U>(target: T, source: U): T & U {
+	if (isArray(target) && isArray(source)) {
+		return [...target, ...source] as T & U;
+	}
+
+	if (!isObject(target) || !isObject(source)) {
+		return source as T & U;
+	}
+
+	const output = Object.assign({}, target) as T & U;
+	for (const key in source) {
+		if (isObject((source as any)[key])) {
+			if (!(target as any)[key]) {
+				Object.assign(output as object, { [key]: (source as any)[key] });
+			} else {
+				output[key as keyof T] = deepMerge((target as any)[key], (source as any)[key]);
+			}
+		} else if (isArray((source as any)[key])) {
+			output[key as keyof T] = [...((target as any)[key] || []), ...(source as any)[key]] as (T & U)[keyof T];
+		} else if ((source as any)[key] !== undefined) {
+			Object.assign(output as object, { [key]: (source as any)[key] });
+		}
+	}
+	return output;
+}

package/src/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare const rapidhash: (content: string | Buffer<ArrayBufferLike>) => number | bigint;

package/src/utils/hash.js

@@ -0,0 +1,7 @@
+import { runtimeHash } from "./runtime.js";
+const rapidhash = (content) => {
+  return runtimeHash(content);
+};
+export {
+  rapidhash
+};

package/src/utils/hash.ts

@@ -0,0 +1,5 @@
+import { runtimeHash } from './runtime.ts';
+
+export const rapidhash = (content: string | Buffer<ArrayBufferLike>): number | bigint => {
+	return runtimeHash(content);
+};

package/src/utils/html.d.ts

@@ -0,0 +1 @@
+export { html } from 'ghtml';

package/src/utils/html.js

@@ -0,0 +1,4 @@
+import { html } from "ghtml";
+export {
+  html
+};

package/src/utils/html.ts

@@ -0,0 +1 @@
+export { html } from 'ghtml';

package/src/utils/invariant.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This module contains a simple utility invariant function that throws an error if the condition is not met
+ * @module
+ */
+export declare function invariant(condition: boolean, message?: string): asserts condition;

package/src/utils/invariant.js

@@ -0,0 +1,11 @@
+const prefix = "[ecopages]";
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  const value = message ? `${prefix} ${message}` : `${prefix} An error occurred`;
+  throw new Error(value);
+}
+export {
+  invariant
+};

package/src/utils/invariant.ts

@@ -0,0 +1,15 @@
+/**
+ * This module contains a simple utility invariant function that throws an error if the condition is not met
+ * @module
+ */
+
+const prefix = '[ecopages]';
+
+export function invariant(condition: boolean, message?: string): asserts condition {
+	if (condition) {
+		return;
+	}
+
+	const value = message ? `${prefix} ${message}` : `${prefix} An error occurred`;
+	throw new Error(value);
+}

package/src/utils/locals-utils.d.ts

@@ -0,0 +1,15 @@
+import type { ApiHandlerContext } from '../public-types.js';
+/**
+ * Creates a require function for validating and retrieving request locals.
+ * Supports both single key access and multiple keys with type safety.
+ *
+ * @param getLocals - Function that returns the current locals object
+ * @returns A require function that throws the onMissing response if keys are not found
+ *
+ * @example
+ * ```ts
+ * const require = createRequire(() => context.locals);
+ * const userId = require('userId', () => new Response('Unauthorized', { status: 401 }));
+ * ```
+ */
+export declare function createRequire(getLocals: () => Record<string, unknown>): ApiHandlerContext['require'];

package/src/utils/locals-utils.js

@@ -0,0 +1,24 @@
+function createRequire(getLocals) {
+  return (keyOrKeys, onMissing) => {
+    const locals = getLocals();
+    if (Array.isArray(keyOrKeys)) {
+      const result = {};
+      for (const key of keyOrKeys) {
+        const value2 = locals[key];
+        if (value2 === void 0 || value2 === null) {
+          throw onMissing();
+        }
+        result[key] = value2;
+      }
+      return result;
+    }
+    const value = locals[keyOrKeys];
+    if (value === void 0 || value === null) {
+      throw onMissing();
+    }
+    return value;
+  };
+}
+export {
+  createRequire
+};

package/src/utils/locals-utils.ts

@@ -0,0 +1,37 @@
+import type { ApiHandlerContext } from '../public-types.ts';
+
+/**
+ * Creates a require function for validating and retrieving request locals.
+ * Supports both single key access and multiple keys with type safety.
+ *
+ * @param getLocals - Function that returns the current locals object
+ * @returns A require function that throws the onMissing response if keys are not found
+ *
+ * @example
+ * ```ts
+ * const require = createRequire(() => context.locals);
+ * const userId = require('userId', () => new Response('Unauthorized', { status: 401 }));
+ * ```
+ */
+export function createRequire(getLocals: () => Record<string, unknown>): ApiHandlerContext['require'] {
+	return (keyOrKeys: string | readonly string[], onMissing: () => Response) => {
+		const locals = getLocals();
+		if (Array.isArray(keyOrKeys)) {
+			const result: Record<string, unknown> = {};
+			for (const key of keyOrKeys) {
+				const value = locals[key];
+				if (value === undefined || value === null) {
+					throw onMissing();
+				}
+				result[key] = value;
+			}
+			return result;
+		}
+
+		const value = locals[keyOrKeys as string];
+		if (value === undefined || value === null) {
+			throw onMissing();
+		}
+		return value;
+	};
+}

package/src/utils/parse-cli-args.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parsed command line arguments for the Ecopages server.
+ * @property preview - Whether to run in preview mode
+ * @property build - Whether to run a static build
+ * @property start - Whether to start the server
+ * @property dev - Whether to run in development mode
+ * @property port - Optional port number
+ * @property hostname - Optional hostname
+ * @property reactFastRefresh - Whether React Fast Refresh is enabled
+ */
+export type ReturnParseCliArgs = {
+    preview: boolean;
+    build: boolean;
+    start: boolean;
+    dev: boolean;
+    port?: number;
+    hostname?: string;
+    reactFastRefresh?: boolean;
+};
+/**
+ * Parses command line arguments for the server.
+ * It returns {@link ReturnParseCliArgs}
+ */
+export declare function parseCliArgs(): ReturnParseCliArgs;

package/src/utils/parse-cli-args.js

@@ -0,0 +1,47 @@
+import { parseArgs } from "node:util";
+import { getRuntimeArgv } from "./runtime.js";
+const ECOPAGES_BIN_FILES = ["ecopages.ts", "ecopages.js", "cli.js"];
+const ECOPAGES_AVAILABLE_COMMANDS = ["dev", "build", "start", "preview"];
+function parseCliArgs() {
+  const runtimeArgv = getRuntimeArgv();
+  const { values } = parseArgs({
+    args: runtimeArgv,
+    options: {
+      dev: { type: "boolean" },
+      preview: { type: "boolean" },
+      build: { type: "boolean" },
+      port: { type: "string" },
+      hostname: { type: "string" },
+      "react-fast-refresh": { type: "boolean" }
+    },
+    allowPositionals: true
+  });
+  let command = "";
+  const ecopagesIndex = runtimeArgv.findIndex((arg) => ECOPAGES_BIN_FILES.some((filename) => arg.endsWith(filename)));
+  const isAvailableCommand = ecopagesIndex !== -1;
+  if (isAvailableCommand) {
+    command = ecopagesIndex < runtimeArgv.length - 1 && ECOPAGES_AVAILABLE_COMMANDS.some((cmd) => {
+      return runtimeArgv[ecopagesIndex + 1] === cmd;
+    }) ? runtimeArgv[ecopagesIndex + 1] : "start";
+  }
+  const isStartCommand = command === "start" || !values.dev && !values.build && !values.preview;
+  const isDevCommand = command === "dev" || !!values.dev;
+  const isBuildCommand = command === "build" || !!values.build;
+  const isPreviewCommand = command === "preview" || !!values.preview;
+  const parsedCommandOptions = {
+    preview: isPreviewCommand,
+    build: isBuildCommand,
+    start: isStartCommand,
+    dev: isDevCommand,
+    port: values.port ? Number(values.port) : void 0,
+    hostname: values.hostname,
+    reactFastRefresh: values["react-fast-refresh"]
+  };
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = isDevCommand ? "development" : "production";
+  }
+  return parsedCommandOptions;
+}
+export {
+  parseCliArgs
+};

package/src/utils/parse-cli-args.ts

@@ -0,0 +1,83 @@
+import { parseArgs } from 'node:util';
+import { getRuntimeArgv } from './runtime.ts';
+
+/**
+ * Parsed command line arguments for the Ecopages server.
+ * @property preview - Whether to run in preview mode
+ * @property build - Whether to run a static build
+ * @property start - Whether to start the server
+ * @property dev - Whether to run in development mode
+ * @property port - Optional port number
+ * @property hostname - Optional hostname
+ * @property reactFastRefresh - Whether React Fast Refresh is enabled
+ */
+export type ReturnParseCliArgs = {
+	preview: boolean;
+	build: boolean;
+	start: boolean;
+	dev: boolean;
+	port?: number;
+	hostname?: string;
+	reactFastRefresh?: boolean;
+};
+
+const ECOPAGES_BIN_FILES = ['ecopages.ts', 'ecopages.js', 'cli.js'];
+
+const ECOPAGES_AVAILABLE_COMMANDS = ['dev', 'build', 'start', 'preview'];
+
+/**
+ * Parses command line arguments for the server.
+ * It returns {@link ReturnParseCliArgs}
+ */
+export function parseCliArgs(): ReturnParseCliArgs {
+	const runtimeArgv = getRuntimeArgv();
+
+	const { values } = parseArgs({
+		args: runtimeArgv,
+		options: {
+			dev: { type: 'boolean' },
+			preview: { type: 'boolean' },
+			build: { type: 'boolean' },
+			port: { type: 'string' },
+			hostname: { type: 'string' },
+			'react-fast-refresh': { type: 'boolean' },
+		},
+		allowPositionals: true,
+	});
+
+	let command = '';
+	const ecopagesIndex = runtimeArgv.findIndex((arg) => ECOPAGES_BIN_FILES.some((filename) => arg.endsWith(filename)));
+
+	const isAvailableCommand = ecopagesIndex !== -1;
+
+	if (isAvailableCommand) {
+		command =
+			ecopagesIndex < runtimeArgv.length - 1 &&
+			ECOPAGES_AVAILABLE_COMMANDS.some((cmd) => {
+				return runtimeArgv[ecopagesIndex + 1] === cmd;
+			})
+				? runtimeArgv[ecopagesIndex + 1]
+				: 'start';
+	}
+
+	const isStartCommand = command === 'start' || (!values.dev && !values.build && !values.preview);
+	const isDevCommand = command === 'dev' || !!values.dev;
+	const isBuildCommand = command === 'build' || !!values.build;
+	const isPreviewCommand = command === 'preview' || !!values.preview;
+
+	const parsedCommandOptions = {
+		preview: isPreviewCommand,
+		build: isBuildCommand,
+		start: isStartCommand,
+		dev: isDevCommand,
+		port: values.port ? Number(values.port) : undefined,
+		hostname: values.hostname,
+		reactFastRefresh: values['react-fast-refresh'],
+	};
+
+	if (!process.env.NODE_ENV) {
+		process.env.NODE_ENV = isDevCommand ? 'development' : 'production';
+	}
+
+	return parsedCommandOptions;
+}

package/src/utils/path-utils.module.d.ts

@@ -0,0 +1,5 @@
+declare function getEcoTemplateExtension(filePath: string): string;
+export declare const PathUtils: {
+    getEcoTemplateExtension: typeof getEcoTemplateExtension;
+};
+export {};

package/src/utils/path-utils.module.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+function getEcoTemplateExtension(filePath) {
+  const { name, ext } = path.parse(filePath);
+  const nameParts = name.split(".");
+  const descriptor = nameParts.length > 1 ? nameParts.pop() : void 0;
+  const templateExtension = descriptor ? `.${descriptor}${ext}` : ext;
+  return templateExtension;
+}
+const PathUtils = {
+  getEcoTemplateExtension
+};
+export {
+  PathUtils
+};

package/src/utils/path-utils.module.ts

@@ -0,0 +1,14 @@
+import path from 'node:path';
+
+function getEcoTemplateExtension(filePath: string) {
+	const { name, ext } = path.parse(filePath);
+	const nameParts = name.split('.');
+	const descriptor = nameParts.length > 1 ? nameParts.pop() : undefined;
+	const templateExtension = descriptor ? `.${descriptor}${ext}` : ext;
+
+	return templateExtension;
+}
+
+export const PathUtils = {
+	getEcoTemplateExtension,
+};

package/src/utils/runtime.d.ts

@@ -0,0 +1,11 @@
+export declare const RUNTIME_ERRORS: {
+    readonly BUN_RUNTIME_REQUIRED: "Bun runtime is required";
+};
+type RuntimeBun = typeof Bun;
+export declare function getBunRuntime(): RuntimeBun | undefined;
+export declare function getRequiredBunRuntime(): RuntimeBun;
+export declare function getRuntimeArgv(): string[];
+export declare function isDevelopmentRuntime(): boolean;
+export declare function isProductionRuntime(): boolean;
+export declare function runtimeHash(content: string | Buffer<ArrayBufferLike>): number | bigint;
+export {};

package/src/utils/runtime.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+const RUNTIME_ERRORS = {
+  BUN_RUNTIME_REQUIRED: "Bun runtime is required"
+};
+function getBunRuntime() {
+  return globalThis.Bun;
+}
+function getRequiredBunRuntime() {
+  const bun = getBunRuntime();
+  if (!bun) {
+    throw new Error(RUNTIME_ERRORS.BUN_RUNTIME_REQUIRED);
+  }
+  return bun;
+}
+function getRuntimeArgv() {
+  return process.argv;
+}
+function isDevelopmentRuntime() {
+  return process.env.NODE_ENV === "development";
+}
+function isProductionRuntime() {
+  return process.env.NODE_ENV === "production";
+}
+function runtimeHash(content) {
+  const bun = getBunRuntime();
+  if (bun) {
+    return bun.hash(content);
+  }
+  const hex = createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return BigInt(`0x${hex}`);
+}
+export {
+  RUNTIME_ERRORS,
+  getBunRuntime,
+  getRequiredBunRuntime,
+  getRuntimeArgv,
+  isDevelopmentRuntime,
+  isProductionRuntime,
+  runtimeHash
+};

package/src/utils/runtime.ts

@@ -0,0 +1,44 @@
+import { createHash } from 'node:crypto';
+
+export const RUNTIME_ERRORS = {
+	BUN_RUNTIME_REQUIRED: 'Bun runtime is required',
+} as const;
+
+type RuntimeBun = typeof Bun;
+
+export function getBunRuntime(): RuntimeBun | undefined {
+	return (globalThis as { Bun?: RuntimeBun }).Bun;
+}
+
+export function getRequiredBunRuntime(): RuntimeBun {
+	const bun = getBunRuntime();
+
+	if (!bun) {
+		throw new Error(RUNTIME_ERRORS.BUN_RUNTIME_REQUIRED);
+	}
+
+	return bun;
+}
+
+export function getRuntimeArgv(): string[] {
+	return process.argv;
+}
+
+export function isDevelopmentRuntime(): boolean {
+	return process.env.NODE_ENV === 'development';
+}
+
+export function isProductionRuntime(): boolean {
+	return process.env.NODE_ENV === 'production';
+}
+
+export function runtimeHash(content: string | Buffer<ArrayBufferLike>): number | bigint {
+	const bun = getBunRuntime();
+
+	if (bun) {
+		return bun.hash(content);
+	}
+
+	const hex = createHash('sha256').update(content).digest('hex').slice(0, 16);
+	return BigInt(`0x${hex}`);
+}

package/src/utils/server-utils.module.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Get the content type of a file based on its extension.
+ * @param file - The file name.
+ * @returns The content type.
+ */
+export declare const getContentType: (file: string) => string;
+/**
+ * Check if a file path has a known static file extension.
+ * @param file - The file name or path.
+ * @returns true if the extension is recognized.
+ */
+export declare const hasKnownExtension: (file: string) => boolean;
+/**
+ * A module for server utilities.
+ */
+export declare const ServerUtils: {
+    getContentType: (file: string) => string;
+    hasKnownExtension: (file: string) => boolean;
+};

package/src/utils/server-utils.module.js

@@ -0,0 +1,56 @@
+const ContentTypeMap = /* @__PURE__ */ new Map([
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["png", "image/png"],
+  ["gif", "image/gif"],
+  ["bmp", "image/bmp"],
+  ["svg", "image/svg+xml"],
+  ["tiff", "image/tiff"],
+  ["webp", "image/webp"],
+  ["avif", "image/avif"],
+  ["ico", "image/x-icon"],
+  ["mp3", "audio/mpeg"],
+  ["ogg", "audio/ogg"],
+  ["wav", "audio/wav"],
+  ["mp4", "video/mp4"],
+  ["webm", "video/webm"],
+  ["ogv", "video/ogg"],
+  ["mov", "video/quicktime"],
+  ["txt", "text/plain"],
+  ["html", "text/html"],
+  ["css", "text/css"],
+  ["js", "text/javascript"],
+  ["mjs", "text/javascript"],
+  ["json", "application/json"],
+  ["map", "application/json"],
+  ["xml", "application/xml"],
+  ["webmanifest", "application/manifest+json"],
+  ["wasm", "application/wasm"],
+  ["csv", "text/csv"],
+  ["ttf", "font/ttf"],
+  ["woff", "font/woff"],
+  ["woff2", "font/woff2"],
+  ["otf", "font/otf"],
+  ["eot", "application/vnd.ms-fontobject"],
+  ["gz", "application/x-gzip"],
+  ["zip", "application/zip"],
+  ["pdf", "application/pdf"],
+  ["doc", "application/msword"]
+]);
+const getContentType = (file) => {
+  const extension = file.split(".").pop() || "txt";
+  return ContentTypeMap.get(extension) || "text/plain";
+};
+const hasKnownExtension = (file) => {
+  const extension = file.split(".").pop();
+  return extension !== void 0 && ContentTypeMap.has(extension);
+};
+const ServerUtils = {
+  getContentType,
+  hasKnownExtension
+};
+export {
+  ServerUtils,
+  getContentType,
+  hasKnownExtension
+};