elegance-js 2.1.23 → 2.1.26

package/dist/server/server.mjs

@@ -1,429 +0,0 @@
-import { createServer as createHttpServer } from "http";
-import { promises as fs } from "fs";
-import { join, normalize, extname, dirname } from "path";
-import { pathToFileURL } from "url";
-import { log } from "../log";
-import { gzip, deflate } from "zlib";
-import { promisify } from "util";
-import { doesPageExist, getPage } from "../compilation/dynamic_compiler";
-const gzipAsync = promisify(gzip);
-const deflateAsync = promisify(deflate);
-const MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".txt": "text/plain; charset=utf-8"
-};
-function startServer({
-  root,
-  pagesDirectory,
-  port = 3e3,
-  host = "localhost",
-  environment = "production",
-  DIST_DIR
-}) {
-  if (!root) throw new Error("Root directory must be specified.");
-  if (!pagesDirectory) throw new Error("Pages directory must be specified.");
-  root = normalize(root).replace(/[\\/]+$/, "");
-  pagesDirectory = normalize(pagesDirectory).replace(/[\\/]+$/, "");
-  const requestHandler = async (req, res) => {
-    try {
-      if (!req.url) {
-        await sendResponse(req, res, 400, {
-          "Content-Type": "text/plain; charset=utf-8"
-        }, "Bad Request");
-        return;
-      }
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
-      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-      if (req.method === "OPTIONS") {
-        res.writeHead(204);
-        res.end();
-        if (environment === "development") {
-          log.info(req.method, "::", req.url, "-", res.statusCode);
-        }
-        return;
-      }
-      const url = new URL(req.url, `http://${req.headers.host}`);
-      if (url.pathname.startsWith("/api/")) {
-        await handleApiRequest(pagesDirectory, url.pathname, req, res);
-      } else if (doesPageExist(url.pathname)) {
-        await handlePageRequest(root, pagesDirectory, url.pathname, req, res, DIST_DIR, getPage(url.pathname));
-      } else {
-        await handleStaticRequest(root, pagesDirectory, url.pathname, req, res, DIST_DIR);
-      }
-      if (environment === "development") {
-        log.info(req.method, "::", req.url, "-", res.statusCode);
-      }
-    } catch (err) {
-      log.error(err);
-      await sendResponse(req, res, 500, {
-        "Content-Type": "text/plain; charset=utf-8"
-      }, "Internal Server Error");
-    }
-  };
-  function attemptListen(p) {
-    const server = createHttpServer(requestHandler);
-    server.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        attemptListen(p + 1);
-      } else {
-        console.error(err);
-      }
-    });
-    server.listen(p, host, () => {
-      log.info(`Server running at http://${host}:${p}/`);
-    });
-    return server;
-  }
-  return attemptListen(port);
-}
-async function getTargetInfo(root, pathname) {
-  const originalPathname = pathname;
-  const filePath = normalize(join(root, decodeURIComponent(pathname))).replace(/[\\/]+$/, "");
-  if (!filePath.startsWith(root)) {
-    throw new Error("Forbidden");
-  }
-  let stats;
-  try {
-    stats = await fs.stat(filePath);
-  } catch {
-  }
-  let targetDir;
-  if (stats) {
-    targetDir = stats.isDirectory() ? filePath : dirname(filePath);
-  } else {
-    targetDir = originalPathname.endsWith("/") ? filePath : dirname(filePath);
-  }
-  return {
-    filePath,
-    targetDir,
-    stats
-  };
-}
-function getMiddlewareDirs(base, parts) {
-  const middlewareDirs = [];
-  let current = base;
-  middlewareDirs.push(current);
-  for (const part of parts) {
-    current = join(current, part);
-    middlewareDirs.push(current);
-  }
-  return middlewareDirs;
-}
-async function collectMiddlewares(dirs) {
-  const middlewares = [];
-  for (const dir of dirs) {
-    const mwPath = join(dir, "middleware.ts");
-    let mwModule;
-    try {
-      await fs.access(mwPath);
-      const url = pathToFileURL(mwPath).href;
-      mwModule = await import(url);
-    } catch {
-      continue;
-    }
-    const mwKeys = Object.keys(mwModule).sort();
-    for (const key of mwKeys) {
-      const f = mwModule[key];
-      if (typeof f === "function" && !middlewares.some((existing) => existing === f)) {
-        middlewares.push(f);
-      }
-    }
-  }
-  return middlewares;
-}
-async function handlePageRequest(root, pagesDirectory, pathname, req, res, DIST_DIR, pageInfo) {
-  try {
-    const {
-      filePath,
-      targetDir,
-      stats
-    } = await getTargetInfo(root, pathname);
-    const relDir = targetDir.slice(root.length).replace(/^[\/\\]+/, "");
-    const parts = relDir.split(/[\\/]/).filter(Boolean);
-    const middlewareDirs = getMiddlewareDirs(pagesDirectory, parts);
-    const middlewares = await collectMiddlewares(middlewareDirs);
-    const data = {};
-    const isDynamic = pageInfo.isDynamic;
-    const handlerPath = isDynamic ? pageInfo.filePath : join(filePath, "index.html");
-    let hasHandler = false;
-    try {
-      await fs.access(handlerPath);
-      hasHandler = true;
-    } catch {
-    }
-    const finalHandler = async (req2, res2) => {
-      if (!hasHandler) {
-        await respondWithErrorPage(root, pathname, 404, req2, res2);
-        return;
-      }
-      if (isDynamic) {
-        try {
-          const {
-            buildDynamicPage
-          } = await import("../compilation/dynamic_compiler");
-          const result = await buildDynamicPage(
-            DIST_DIR,
-            pathname,
-            pageInfo,
-            req2,
-            res2,
-            data
-          );
-          if (result === false) {
-            return;
-          }
-          const {
-            resultHTML
-          } = result;
-          if (resultHTML === false) {
-            return;
-          }
-          await sendResponse(req2, res2, 200, {
-            "Content-Type": MIME_TYPES[".html"]
-          }, resultHTML);
-        } catch (err) {
-          log.error("Error building dynamic page -", err);
-        }
-      } else {
-        const ext = extname(handlerPath).toLowerCase();
-        const contentType = MIME_TYPES[ext] || "application/octet-stream";
-        const fileData = await fs.readFile(handlerPath);
-        await sendResponse(req2, res2, 200, {
-          "Content-Type": contentType
-        }, fileData);
-      }
-    };
-    const composed = composeMiddlewares(middlewares, finalHandler, {
-      isApi: false,
-      root,
-      pathname,
-      data
-    });
-    await composed(req, res);
-  } catch (err) {
-    if (err.message === "Forbidden") {
-      await sendResponse(req, res, 403, {
-        "Content-Type": "text/plain; charset=utf-8"
-      }, "Forbidden");
-    } else {
-      throw err;
-    }
-  }
-}
-async function handleStaticRequest(root, pagesDirectory, pathname, req, res, DIST_DIR) {
-  try {
-    const {
-      filePath,
-      targetDir,
-      stats
-    } = await getTargetInfo(root, pathname);
-    const relDir = targetDir.slice(root.length).replace(/^[\/\\]+/, "");
-    const parts = relDir.split(/[\\/]/).filter(Boolean);
-    const middlewareDirs = getMiddlewareDirs(pagesDirectory, parts);
-    const middlewares = await collectMiddlewares(middlewareDirs);
-    let handlerPath = filePath;
-    if (stats && stats.isDirectory()) {
-      handlerPath = join(filePath, "index.html");
-    }
-    let hasHandler = false;
-    try {
-      await fs.access(handlerPath);
-      hasHandler = true;
-    } catch {
-    }
-    const finalHandler = async (req2, res2) => {
-      if (!hasHandler) {
-        await respondWithErrorPage(root, pathname, 404, req2, res2);
-        return;
-      }
-      const ext = extname(handlerPath).toLowerCase();
-      const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      const fileData = await fs.readFile(handlerPath);
-      await sendResponse(req2, res2, 200, {
-        "Content-Type": contentType
-      }, fileData);
-    };
-    const composed = composeMiddlewares(middlewares, finalHandler, {
-      isApi: false,
-      root,
-      pathname
-    });
-    await composed(req, res);
-  } catch (err) {
-    if (err.message === "Forbidden") {
-      await sendResponse(req, res, 403, {
-        "Content-Type": "text/plain; charset=utf-8"
-      }, "Forbidden");
-    } else {
-      throw err;
-    }
-  }
-}
-async function handleApiRequest(pagesDirectory, pathname, req, res) {
-  const apiSubPath = pathname.slice("/api/".length);
-  const parts = apiSubPath.split("/").filter(Boolean);
-  const middlewareDirs = getMiddlewareDirs(join(pagesDirectory, "api"), parts);
-  const middlewares = await collectMiddlewares(middlewareDirs);
-  const routeDir = middlewareDirs[middlewareDirs.length - 1];
-  const routePath = join(routeDir, "route.ts");
-  let hasRoute = false;
-  try {
-    await fs.access(routePath);
-    hasRoute = true;
-  } catch {
-  }
-  let fn = null;
-  let module = null;
-  if (hasRoute) {
-    try {
-      const moduleUrl = pathToFileURL(routePath).href;
-      module = await import(moduleUrl);
-      fn = module[req.method];
-    } catch (err) {
-      console.error(err);
-      return respondWithJsonError(req, res, 500, "Internal Server Error");
-    }
-  }
-  const finalHandler = async (req2, res2) => {
-    if (!hasRoute) {
-      return respondWithJsonError(req2, res2, 404, "Not Found");
-    }
-    if (typeof fn !== "function") {
-      return respondWithJsonError(req2, res2, 405, "Method Not Allowed");
-    }
-    await fn(req2, res2);
-  };
-  const composed = composeMiddlewares(middlewares, finalHandler, {
-    isApi: true
-  });
-  await composed(req, res);
-}
-function composeMiddlewares(mws, final, options) {
-  return async function(req, res) {
-    let index = 0;
-    async function dispatch(err) {
-      if (err) {
-        if (options.isApi) {
-          return respondWithJsonError(req, res, 500, err.message || "Internal Server Error");
-        } else {
-          return await respondWithErrorPage(options.root, options.pathname, 500, req, res);
-        }
-      }
-      if (index >= mws.length) {
-        return await final(req, res);
-      }
-      const thisMw = mws[index++];
-      const next = (e) => dispatch(e);
-      const onceNext = (nextFn) => {
-        let called = false;
-        return async (e) => {
-          if (called) {
-            log.warn("next() was called in a middleware more than once.");
-            return;
-          }
-          called = true;
-          await nextFn(e);
-        };
-      };
-      try {
-        await thisMw(req, res, onceNext(next), options.data || {});
-      } catch (error) {
-        await dispatch(error);
-      }
-    }
-    await dispatch();
-  };
-}
-async function respondWithJsonError(req, res, code, message) {
-  const body = JSON.stringify({
-    error: message
-  });
-  await sendResponse(req, res, code, {
-    "Content-Type": "application/json; charset=utf-8"
-  }, body);
-}
-async function respondWithErrorPage(root, pathname, code, req, res) {
-  let currentPath = normalize(join(root, decodeURIComponent(pathname)));
-  let tried = /* @__PURE__ */ new Set();
-  let errorFilePath = null;
-  while (currentPath.startsWith(root)) {
-    const candidate = join(currentPath, `${code}.html`);
-    if (!tried.has(candidate)) {
-      try {
-        await fs.access(candidate);
-        errorFilePath = candidate;
-        break;
-      } catch {
-      }
-      tried.add(candidate);
-    }
-    const parent = dirname(currentPath);
-    if (parent === currentPath) break;
-    currentPath = parent;
-  }
-  if (!errorFilePath) {
-    const fallback = join(root, `${code}.html`);
-    try {
-      await fs.access(fallback);
-      errorFilePath = fallback;
-    } catch {
-    }
-  }
-  if (errorFilePath) {
-    try {
-      const html = await fs.readFile(errorFilePath, "utf8");
-      await sendResponse(req, res, code, {
-        "Content-Type": "text/html; charset=utf-8"
-      }, html);
-      return;
-    } catch {
-    }
-  }
-  await sendResponse(req, res, code, {
-    "Content-Type": "text/plain; charset=utf-8"
-  }, `${code} Error`);
-}
-function isCompressible(contentType) {
-  if (!contentType) return false;
-  return /text\/|javascript|json|xml|svg/.test(contentType);
-}
-async function sendResponse(req, res, status, headers, body) {
-  let bufferBody = typeof body === "string" ? Buffer.from(body) : body;
-  const accept = req.headers["accept-encoding"] || "";
-  let encoding = null;
-  if (accept.match(/\bgzip\b/)) {
-    encoding = "gzip";
-  } else if (accept.match(/\bdeflate\b/)) {
-    encoding = "deflate";
-  }
-  if (!encoding || !isCompressible(headers["Content-Type"] || "")) {
-    res.writeHead(status, headers);
-    res.end(bufferBody);
-    return;
-  }
-  const compressor = encoding === "gzip" ? gzipAsync : deflateAsync;
-  try {
-    const compressed = await compressor(bufferBody);
-    headers["Content-Encoding"] = encoding;
-    headers["Vary"] = "Accept-Encoding";
-    res.writeHead(status, headers);
-    res.end(compressed);
-  } catch (err) {
-    log.error("Compression error:", err);
-    res.writeHead(status, headers);
-    res.end(bufferBody);
-  }
-}
-export {
-  startServer
-};

package/dist/server/state.d.ts

@@ -1,61 +0,0 @@
-import { ObjectAttributeType } from "../helpers/ObjectAttributeType";
-type ClientSubjectGeneric<T> = Omit<ClientSubject, "value"> & {
-    value: T;
-};
-type Widen<T> = T extends number ? number : T extends string ? string : T extends boolean ? boolean : T extends {} ? T & Record<string, any> : T;
-export declare const state: <U extends number | string | boolean | {} | undefined | null | Array<any>>(value: U, options?: {
-    isGlobal: boolean;
-}) => {
-    id: number;
-    value: Widen<U>;
-    type: ObjectAttributeType.STATE;
-    bind: string | undefined;
-    reactiveMap: U extends Array<any> ? ReactiveMap<U, any> : null;
-};
-type ReactiveMap<T extends any[], D extends Dependencies> = (this: {
-    id: number;
-    value: any;
-    type: ObjectAttributeType.STATE;
-    bind: string | undefined;
-}, template: (item: T[number], index: number, ...deps: {
-    [K in keyof D]: ClientSubjectGeneric<D[K]>["value"];
-}) => Child, deps?: [...D]) => Child;
-type Dependencies = {
-    type: ObjectAttributeType;
-    value: unknown;
-    id: number;
-    bind?: string;
-}[];
-export type SetEvent<Event, Target> = Omit<Event, "currentTarget"> & {
-    currentTarget: Target;
-};
-export declare const eventListener: <D extends Dependencies, E extends Event, T>(dependencies: [...D] | [], eventListener: (event: SetEvent<E, T>, ...subjects: { [K in keyof D]: ClientSubjectGeneric<D[K]["value"]>; }) => void) => {
-    id: number;
-    type: ObjectAttributeType;
-    value: Function;
-};
-export declare const initializeState: () => never[];
-export declare const getState: () => {
-    value: unknown;
-    type: ObjectAttributeType;
-    id: number;
-    bind?: number;
-}[];
-export declare const initializeObjectAttributes: () => never[];
-export declare const getObjectAttributes: () => ({
-    type: ObjectAttributeType;
-    id: string | number;
-    value: any;
-    bind?: string;
-} | {
-    type: ObjectAttributeType;
-    refs: {
-        id: number;
-        bind?: string;
-    }[];
-    initialValues: any[];
-    update: (...value: any) => any;
-} | {
-    type: ObjectAttributeType;
-})[];
-export {};

package/dist/server/state.mjs

@@ -1,146 +0,0 @@
-import { ObjectAttributeType } from "../helpers/ObjectAttributeType";
-import { loadHook } from "./loadHook";
-if (!globalThis.__SERVER_CURRENT_STATE_ID__) {
-  globalThis.__SERVER_CURRENT_STATE_ID__ = 1;
-}
-const state = (value, options) => {
-  const serverStateEntry = {
-    id: __SERVER_CURRENT_STATE_ID__ += 1,
-    value,
-    type: ObjectAttributeType.STATE
-  };
-  globalThis.__SERVER_CURRENT_STATE__.push(serverStateEntry);
-  if (Array.isArray(value)) {
-    serverStateEntry.reactiveMap = reactiveMap;
-  }
-  return serverStateEntry;
-};
-const reactiveMap = function(template, deps) {
-  const subject = this;
-  const dependencies = state(deps || []);
-  const templateFn = state(template);
-  loadHook(
-    [subject, templateFn, dependencies],
-    (state2, subject2, templateFn2, dependencies2) => {
-      const el = document.querySelector(
-        `[map-id="${subject2.id}"]`
-      );
-      if (!el) {
-        console.error(`Couldn't find map tag with map-id=${subject2.id}`);
-        return;
-      }
-      const parentElement = el.parentElement;
-      const nextSibling = el.nextSibling;
-      el.remove();
-      const value = subject2.value;
-      const deps2 = state2.getAll(dependencies2.value.map((dep) => ({ id: dep.id, bind: dep.bind })));
-      const attributes = [];
-      const currentlyWatched = [];
-      const createElements = () => {
-        for (let i = 0; i < value.length; i += 1) {
-          const htmlElement = client.renderRecursively(templateFn2.value(value[i], i, ...deps2), attributes);
-          htmlElement.setAttribute("map-id", subject2.id.toString());
-          const elementKey = ((i - 1) * -1).toString();
-          htmlElement.setAttribute("key", elementKey);
-          for (const attribute of attributes) {
-            let values = {};
-            const type = attribute.type;
-            switch (type) {
-              case ObjectAttributeType.OBSERVER: {
-                const { field, subjects, updateCallback } = attribute;
-                for (const reference of subjects) {
-                  const subject3 = state2.get(reference.id, reference.bind);
-                  const updateFunction = (value2) => {
-                    values[subject3.id] = value2;
-                    try {
-                      const newValue = updateCallback(...Object.values(values));
-                      let attribute2 = field === "class" ? "className" : field;
-                      htmlElement[attribute2] = newValue;
-                    } catch (e) {
-                      console.error(e);
-                      return;
-                    }
-                  };
-                  updateFunction(subject3.value);
-                  state2.observe(subject3, updateFunction, elementKey);
-                  currentlyWatched.push({
-                    key: elementKey,
-                    subject: subject3
-                  });
-                }
-                break;
-              }
-              case ObjectAttributeType.STATE: {
-                const { field, element, subjects, eventListener: eventListener2 } = attribute;
-                const lc = field.toLowerCase();
-                const fn = (event) => {
-                  eventListener2(event, ...subjects);
-                };
-                element[lc] = fn;
-                break;
-              }
-            }
-          }
-          parentElement.insertBefore(htmlElement, nextSibling);
-          attributes.splice(0, attributes.length);
-        }
-      };
-      const removeOldElements = () => {
-        const list = Array.from(document.querySelectorAll(`[map-id="${subject2.id}"]`));
-        for (const el2 of list) {
-          el2.remove();
-        }
-        for (const watched of currentlyWatched) {
-          state2.unobserve(watched.subject, watched.key);
-        }
-        currentlyWatched.splice(0, currentlyWatched.length);
-      };
-      createElements();
-      const uniqueId = `${Date.now()}`;
-      state2.observe(subject2, (value2) => {
-        removeOldElements();
-        createElements();
-      }, uniqueId);
-    }
-  );
-  return globalThis.template({
-    "map-id": subject.id
-  });
-};
-const eventListener = (dependencies, eventListener2) => {
-  const deps = dependencies.map((dep) => ({ id: dep.id, bind: dep.bind }));
-  let dependencyString = "[";
-  for (const dep of deps) {
-    dependencyString += `{id:${dep.id}`;
-    if (dep.bind) dependencyString += `,bind:${dep.bind}`;
-    dependencyString += `},`;
-  }
-  dependencyString += "]";
-  const value = {
-    id: __SERVER_CURRENT_STATE_ID__ += 1,
-    type: ObjectAttributeType.STATE,
-    value: new Function(
-      "state",
-      "event",
-      `(${eventListener2.toString()})(event, ...state.getAll(${dependencyString}))`
-    )
-  };
-  globalThis.__SERVER_CURRENT_STATE__.push(value);
-  return value;
-};
-const initializeState = () => globalThis.__SERVER_CURRENT_STATE__ = [];
-const getState = () => {
-  return globalThis.__SERVER_CURRENT_STATE__;
-};
-const initializeObjectAttributes = () => globalThis.__SERVER_CURRENT_OBJECT_ATTRIBUTES__ = [];
-const getObjectAttributes = () => {
-  return globalThis.__SERVER_CURRENT_OBJECT_ATTRIBUTES__;
-};
-export {
-  eventListener,
-  getObjectAttributes,
-  getState,
-  initializeObjectAttributes,
-  initializeState,
-  state
-};

package/dist/shared/bindServerElements.mjs

@@ -1,3 +0,0 @@
-import { elements, childrenlessElements } from "./serverElements";
-Object.assign(globalThis, elements);
-Object.assign(globalThis, childrenlessElements);

package/dist/shared/serverElements.d.ts

@@ -1,11 +0,0 @@
-declare const createElementOptions: (obj: Record<string, any>) => () => Record<string, any>;
-declare const elements: {
-    [key: string]: EleganceElement<ElementTags>;
-};
-declare const childrenlessElements: {
-    [key: string]: EleganceChildrenlessElement<ChildrenlessElementTags>;
-};
-declare const allElements: {
-    [x: string]: EleganceElement<ElementTags> | EleganceChildrenlessElement<ChildrenlessElementTags>;
-};
-export { elements, childrenlessElements, createElementOptions, allElements };