elegance-js 1.0.0

package/dist/docs/utils/MEGALEXER.mjs

@@ -0,0 +1,171 @@
+// src/docs/utils/MEGALEXER.ts
+var tokenize = (input) => {
+  const tokens = [];
+  const length = input.length;
+  let index = 0;
+  const keywords = /* @__PURE__ */ new Set([
+    "if",
+    "else",
+    "for",
+    "while",
+    "function",
+    "return",
+    "class",
+    "const",
+    "let",
+    "var",
+    "interface",
+    "extends",
+    "implements",
+    "export",
+    "import",
+    "from"
+  ]);
+  const operatorChars = /* @__PURE__ */ new Set([
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "=",
+    ">",
+    "<",
+    "!",
+    "&",
+    "|",
+    "^",
+    "~",
+    "?",
+    ":"
+  ]);
+  const punctuationChars = /* @__PURE__ */ new Set([
+    ";",
+    ",",
+    ".",
+    "(",
+    ")",
+    "{",
+    "}",
+    "[",
+    "]"
+  ]);
+  const peek = (offset = 1) => index + offset < length ? input[index + offset] : "";
+  const readWhile = (predicate) => {
+    const start = index;
+    while (index < length && predicate(input[index])) {
+      index++;
+    }
+    return input.slice(start, index);
+  };
+  const readString = (quoteType) => {
+    let value = input[index++];
+    while (index < length && input[index] !== quoteType) {
+      if (input[index] === "\\") {
+        value += input[index++];
+        if (index < length) {
+          value += input[index++];
+        }
+      } else {
+        value += input[index++];
+      }
+    }
+    if (index < length) {
+      value += input[index++];
+    }
+    return value;
+  };
+  const readLineComment = () => {
+    const start = index;
+    index += 2;
+    while (index < length && input[index] !== "\n") {
+      index++;
+    }
+    return input.slice(start, index);
+  };
+  const readBlockComment = () => {
+    const start = index;
+    index += 2;
+    while (index < length && !(input[index] === "*" && peek() === "/")) {
+      index++;
+    }
+    if (index < length) {
+      index += 2;
+    }
+    return input.slice(start, index);
+  };
+  while (index < length) {
+    const char = input[index];
+    const startPos = index;
+    if (/\s/.test(char)) {
+      const value = readWhile((c) => /\s/.test(c));
+      tokens.push({ type: "" /* Whitespace */, value, position: startPos });
+      continue;
+    }
+    if (char === "/") {
+      if (peek() === "/") {
+        const value = readLineComment();
+        tokens.push({ type: "text-gray-400" /* Comment */, value, position: startPos });
+        continue;
+      } else if (peek() === "*") {
+        const value = readBlockComment();
+        tokens.push({ type: "text-gray-400" /* Comment */, value, position: startPos });
+        continue;
+      }
+    }
+    if (char === '"' || char === "'") {
+      const value = readString(char);
+      tokens.push({ type: "text-green-200" /* String */, value, position: startPos });
+      continue;
+    }
+    if (/\d/.test(char)) {
+      const value = readWhile((c) => /[\d\.]/.test(c));
+      tokens.push({ type: "text-blue-400" /* Number */, value, position: startPos });
+      continue;
+    }
+    if (/[a-zA-Z_$]/.test(char)) {
+      const value = readWhile((c) => /[a-zA-Z0-9_$]/.test(c));
+      let type = "text-orange-300" /* Identifier */;
+      if (keywords.has(value)) {
+        type = "text-amber-100 font-semibold" /* Keyword */;
+      } else if (value === "true" || value === "false") {
+        type = "text-blue-200" /* Boolean */;
+      }
+      let tempIndex = index;
+      while (tempIndex < length && /\s/.test(input[tempIndex])) {
+        tempIndex++;
+      }
+      if (tempIndex < length && input[tempIndex] === "(") {
+        type = "text-red-300" /* FunctionCall */;
+      }
+      tokens.push({ type, value, position: startPos });
+      continue;
+    }
+    if (operatorChars.has(char)) {
+      let value = char;
+      index++;
+      if (index < length && operatorChars.has(input[index])) {
+        value += input[index++];
+      }
+      tokens.push({ type: "" /* Operator */, value, position: startPos });
+      continue;
+    }
+    if (punctuationChars.has(char)) {
+      tokens.push({ type: "text-gray-400" /* Punctuation */, value: char, position: startPos });
+      index++;
+      continue;
+    }
+    tokens.push({ type: "" /* Unknown */, value: char, position: startPos });
+    index++;
+  }
+  return tokens;
+};
+var escapeHtml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+var highlightCode = (code) => {
+  const tokens = tokenize(code);
+  return tokens.map(
+    (token) => token.type === "" /* Whitespace */ ? token.value : `<span class="${token.type}">${escapeHtml(token.value)}</span>`
+  ).join("");
+};
+export {
+  highlightCode
+};

package/dist/global.d.ts

@@ -0,0 +1,290 @@
+import { ObjectAttributeType } from "./helpers/ObjectAttributeType";
+declare global {
+    type NonVoid<T> = T extends void ? never : T;
+    var __ELEGANCE_SERVER_DATA__: any;
+    var __SERVER_CURRENT_STATE_ID__: number;
+    var __SERVER_CURRENT_REF_ID__: number;
+    var __SERVER_CURRENT_STATE__: Array<{
+        value: unknown;
+        type: ObjectAttributeType;
+        id: number;
+        bind?: number;
+    }>;
+    var __SERVER_CURRENT_LOADHOOKS__: Array<any>;
+    var __SERVER_CURRENT_LAYOUTS__: Map<string, number>;
+    var __SERVER_CURRENT_LAYOUT_ID__: number;
+    type AnyBuiltElement = BuiltElement<ElementTags> | ChildrenLessBuiltElement<ChildrenlessElementTags>;
+    type BuiltElement<T> = {
+        tag: T;
+        children: ElementChildren;
+        options: Record<string, any> | Child;
+    };
+    type ChildrenLessBuiltElement<T> = {
+        tag: T;
+        children: null;
+        options: Record<string, any> | Child;
+    };
+    type PageOptions = {
+        build: "once" | "interval" | "request";
+    };
+    type Page = (AnyBuiltElement) | (() => AnyBuiltElement);
+    type ObjectAttribute<T> = T extends ObjectAttributeType.STATE ? {
+        type: ObjectAttributeType;
+        id: string | number;
+        value: any;
+        bind?: string;
+    } : T extends ObjectAttributeType.OBSERVER ? {
+        type: ObjectAttributeType;
+        refs: {
+            id: number;
+            bind?: string;
+        }[];
+        initialValues: any[];
+        update: (...value: any) => any;
+    } : {
+        type: ObjectAttributeType;
+    };
+    type ElementOptions = {
+        [key: string]: string | number | boolean | {
+            type: ObjectAttributeType;
+            id: string | number;
+            value: any;
+        } | {
+            type: ObjectAttributeType;
+            refs: {
+                id: number;
+                bind?: string;
+            }[];
+            initialValues: any[];
+            update: (...value: any) => any;
+        } | {
+            type: ObjectAttributeType;
+        };
+    } & GlobalAttributes & EventHandlers;
+    type EleganceElement<T> = (options?: ElementOptions | Child, ...children: ElementChildren) => BuiltElement<T>;
+    type EleganceChildrenlessElement<T> = (options?: ElementOptions) => ChildrenLessBuiltElement<T>;
+    type Child = BuiltElement<ElementTags> | ChildrenLessBuiltElement<ChildrenlessElementTags> | string | boolean | number | Array<number | string | boolean>;
+    type ElementChildren = Array<Child>;
+    type OmitSomething<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+    type AllowedHTMLElements = OmitSomething<HTMLElementTagNameMap, "var">;
+    interface GlobalAttributes {
+        [key: `data-${string}`]: string | undefined;
+        [key: `aria-${string}`]: string | undefined;
+    }
+    type ChildrenlessElementTags = "area" | "base" | "br" | "col" | "embed" | "hr" | "img" | "input" | "link" | "meta" | "source" | "track" | "path" | "rect";
+    type ElementTags = "a" | "address" | "article" | "aside" | "audio" | "blockquote" | "body" | "button" | "canvas" | "caption" | "colgroup" | "data" | "span" | "datalist" | "dd" | "del" | "details" | "dialog" | "div" | "dl" | "dt" | "fieldset" | "figcaption" | "figure" | "footer" | "form" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "head" | "header" | "hgroup" | "html" | "iframe" | "ins" | "label" | "legend" | "li" | "main" | "map" | "meter" | "menu" | "nav" | "noscript" | "object" | "ol" | "optgroup" | "option" | "output" | "p" | "picture" | "pre" | "progress" | "q" | "script" | "search" | "section" | "select" | "slot" | "summary" | "table" | "tbody" | "td" | "template" | "textarea" | "tfoot" | "th" | "thead" | "time" | "tr" | "ul" | "video" | "abbr" | "b" | "bdi" | "bdo" | "cite" | "code" | "dfn" | "em" | "i" | "kbd" | "mark" | "rp" | "rt" | "ruby" | "s" | "samp" | "small" | "strong" | "sub" | "sup" | "title" | "u" | "wbr" | "svg";
+    var area: EleganceChildrenlessElement<"area">;
+    var base: EleganceChildrenlessElement<"base">;
+    var br: EleganceChildrenlessElement<"br">;
+    var col: EleganceChildrenlessElement<"col">;
+    var embed: EleganceChildrenlessElement<"embed">;
+    var hr: EleganceChildrenlessElement<"hr">;
+    var img: EleganceChildrenlessElement<"img">;
+    var input: EleganceChildrenlessElement<"input">;
+    var link: EleganceChildrenlessElement<"link">;
+    var meta: EleganceChildrenlessElement<"meta">;
+    var source: EleganceChildrenlessElement<"source">;
+    var track: EleganceChildrenlessElement<"track">;
+    var path: EleganceChildrenlessElement<"path">;
+    var rect: EleganceChildrenlessElement<"rect">;
+    var svg: EleganceElement<"svg">;
+    var a: EleganceElement<"a">;
+    var address: EleganceElement<"address">;
+    var article: EleganceElement<"article">;
+    var aside: EleganceElement<"aside">;
+    var audio: EleganceElement<"audio">;
+    var blockquote: EleganceElement<"blockquote">;
+    var body: EleganceElement<"body">;
+    var button: EleganceElement<"button">;
+    var canvas: EleganceElement<"canvas">;
+    var caption: EleganceElement<"caption">;
+    var colgroup: EleganceElement<"colgroup">;
+    var data: EleganceElement<"data">;
+    var datalist: EleganceElement<"datalist">;
+    var dd: EleganceElement<"dd">;
+    var del: EleganceElement<"del">;
+    var details: EleganceElement<"details">;
+    var dialog: EleganceElement<"dialog">;
+    var div: EleganceElement<"div">;
+    var dl: EleganceElement<"dl">;
+    var dt: EleganceElement<"dt">;
+    var fieldset: EleganceElement<"fieldset">;
+    var figcaption: EleganceElement<"figcaption">;
+    var figure: EleganceElement<"figure">;
+    var footer: EleganceElement<"footer">;
+    var form: EleganceElement<"form">;
+    var h1: EleganceElement<"h1">;
+    var h2: EleganceElement<"h2">;
+    var h3: EleganceElement<"h3">;
+    var h4: EleganceElement<"h4">;
+    var h5: EleganceElement<"h5">;
+    var h6: EleganceElement<"h6">;
+    var head: EleganceElement<"head">;
+    var header: EleganceElement<"header">;
+    var hgroup: EleganceElement<"hgroup">;
+    var html: EleganceElement<"html">;
+    var iframe: EleganceElement<"iframe">;
+    var ins: EleganceElement<"ins">;
+    var label: EleganceElement<"label">;
+    var legend: EleganceElement<"legend">;
+    var li: EleganceElement<"li">;
+    var main: EleganceElement<"main">;
+    var map: EleganceElement<"map">;
+    var meter: EleganceElement<"meter">;
+    var menu: EleganceElement<"menu">;
+    var nav: EleganceElement<"nav">;
+    var noscript: EleganceElement<"noscript">;
+    var object: EleganceElement<"object">;
+    var ol: EleganceElement<"ol">;
+    var optgroup: EleganceElement<"optgroup">;
+    var option: EleganceElement<"option">;
+    var output: EleganceElement<"output">;
+    var p: EleganceElement<"p">;
+    var picture: EleganceElement<"picture">;
+    var pre: EleganceElement<"pre">;
+    var progress: EleganceElement<"progress">;
+    var q: EleganceElement<"q">;
+    var script: EleganceElement<"script">;
+    var search: EleganceElement<"search">;
+    var section: EleganceElement<"section">;
+    var select: EleganceElement<"select">;
+    var slot: EleganceElement<"slot">;
+    var style: EleganceElement<"style">;
+    var summary: EleganceElement<"summary">;
+    var table: EleganceElement<"table">;
+    var tbody: EleganceElement<"tbody">;
+    var td: EleganceElement<"td">;
+    var template: EleganceElement<"template">;
+    var textarea: EleganceElement<"textarea">;
+    var tfoot: EleganceElement<"tfoot">;
+    var th: EleganceElement<"th">;
+    var thead: EleganceElement<"thead">;
+    var time: EleganceElement<"time">;
+    var tr: EleganceElement<"tr">;
+    var ul: EleganceElement<"ul">;
+    var video: EleganceElement<"video">;
+    var abbr: EleganceElement<"abbr">;
+    var b: EleganceElement<"b">;
+    var bdi: EleganceElement<"bdi">;
+    var bdo: EleganceElement<"bdo">;
+    var cite: EleganceElement<"cite">;
+    var code: EleganceElement<"code">;
+    var dfn: EleganceElement<"dfn">;
+    var em: EleganceElement<"em">;
+    var i: EleganceElement<"i">;
+    var kbd: EleganceElement<"kbd">;
+    var mark: EleganceElement<"mark">;
+    var rp: EleganceElement<"rp">;
+    var rt: EleganceElement<"rt">;
+    var ruby: EleganceElement<"ruby">;
+    var s: EleganceElement<"s">;
+    var samp: EleganceElement<"samp">;
+    var small: EleganceElement<"small">;
+    var span: EleganceElement<"span">;
+    var strong: EleganceElement<"strong">;
+    var sub: EleganceElement<"sub">;
+    var sup: EleganceElement<"sup">;
+    var u: EleganceElement<"u">;
+    var wbr: EleganceElement<"wbr">;
+    var title: EleganceElement<"title">;
+    type EleganceEventListener = ObjectAttribute<ObjectAttributeType.STATE>;
+    interface EventHandlers {
+        onCopy?: EleganceEventListener;
+        onCut?: EleganceEventListener;
+        onPaste?: EleganceEventListener;
+        onCompositionStart?: EleganceEventListener;
+        onCompositionUpdate?: EleganceEventListener;
+        onCompositionEnd?: EleganceEventListener;
+        onKeyDown?: EleganceEventListener;
+        onKeyPress?: EleganceEventListener;
+        onKeyUp?: EleganceEventListener;
+        onFocus?: EleganceEventListener;
+        onBlur?: EleganceEventListener;
+        onChange?: EleganceEventListener;
+        onInput?: EleganceEventListener;
+        onInvalid?: EleganceEventListener;
+        onSubmit?: EleganceEventListener;
+        onClick?: EleganceEventListener;
+        onDoubleClick?: EleganceEventListener;
+        onMouseDown?: EleganceEventListener;
+        onMouseUp?: EleganceEventListener;
+        onMouseEnter?: EleganceEventListener;
+        onMouseLeave?: EleganceEventListener;
+        onMouseMove?: EleganceEventListener;
+        onMouseOver?: EleganceEventListener;
+        onMouseOut?: EleganceEventListener;
+        onContextMenu?: EleganceEventListener;
+        onDrag?: EleganceEventListener;
+        onDragStart?: EleganceEventListener;
+        onDragEnd?: EleganceEventListener;
+        onDragEnter?: EleganceEventListener;
+        onDragLeave?: EleganceEventListener;
+        onDragOver?: EleganceEventListener;
+        onDrop?: EleganceEventListener;
+        onScroll?: EleganceEventListener;
+        onWheel?: EleganceEventListener;
+        onTouchStart?: EleganceEventListener;
+        onTouchMove?: EleganceEventListener;
+        onTouchEnd?: EleganceEventListener;
+        onTouchCancel?: EleganceEventListener;
+        onPointerDown?: EleganceEventListener;
+        onPointerUp?: EleganceEventListener;
+        onPointerCancel?: EleganceEventListener;
+        onPointerEnter?: EleganceEventListener;
+        onPointerLeave?: EleganceEventListener;
+        onPointerMove?: EleganceEventListener;
+        onPointerOver?: EleganceEventListener;
+        onPointerOut?: EleganceEventListener;
+        onGotPointerCapture?: EleganceEventListener;
+        onLostPointerCapture?: EleganceEventListener;
+        onLoad?: EleganceEventListener;
+        onError?: EleganceEventListener;
+        onAbort?: EleganceEventListener;
+        onCanPlay?: EleganceEventListener;
+        onCanPlayThrough?: EleganceEventListener;
+        onDurationChange?: EleganceEventListener;
+        onEmptied?: EleganceEventListener;
+        onEnded?: EleganceEventListener;
+        onLoadedData?: EleganceEventListener;
+        onLoadedMetadata?: EleganceEventListener;
+        onLoadStart?: EleganceEventListener;
+        onPause?: EleganceEventListener;
+        onPlay?: EleganceEventListener;
+        onPlaying?: EleganceEventListener;
+        onProgress?: EleganceEventListener;
+        onRateChange?: EleganceEventListener;
+        onSeeked?: EleganceEventListener;
+        onSeeking?: EleganceEventListener;
+        onStalled?: EleganceEventListener;
+        onSuspend?: EleganceEventListener;
+        onTimeUpdate?: EleganceEventListener;
+        onVolumeChange?: EleganceEventListener;
+        onWaiting?: EleganceEventListener;
+        onAnimationStart?: EleganceEventListener;
+        onAnimationEnd?: EleganceEventListener;
+        onAnimationIteration?: EleganceEventListener;
+        onTransitionEnd?: EleganceEventListener;
+        onToggle?: EleganceEventListener;
+    }
+    var pd: Record<string, any>;
+    var client: {
+        navigateLocally: (target: string, pushState?: boolean) => any;
+        fetchPage: (targetURL: URL) => Promise<Document | void>;
+        currentPage: string;
+        sanitizePathname: (target: string) => string;
+        getReference: (id: number) => HTMLElement | null;
+    };
+    type ClientSubject = {
+        id: number;
+        value: any;
+        observers: Map<string, (value: any) => any>;
+        pathname: string;
+        signal: () => void;
+    };
+    type State = {
+        subjects: ClientSubject[];
+        get: (id: number) => ClientSubject | undefined;
+        observe: (subject: ClientSubject, observer: (value: any) => any) => void;
+    };
+}
+export {};

package/dist/helpers/ObjectAttributeType.d.ts

@@ -0,0 +1,7 @@
+export declare enum ObjectAttributeType {
+    GENERIC = 0,
+    STATE = 1,
+    OBSERVER = 2,
+    EVENT_LISTENER = 3,
+    REFERENCE = 4
+}

package/dist/helpers/ObjectAttributeType.mjs

@@ -0,0 +1,12 @@
+// src/helpers/ObjectAttributeType.ts
+var ObjectAttributeType = /* @__PURE__ */ ((ObjectAttributeType2) => {
+  ObjectAttributeType2[ObjectAttributeType2["GENERIC"] = 0] = "GENERIC";
+  ObjectAttributeType2[ObjectAttributeType2["STATE"] = 1] = "STATE";
+  ObjectAttributeType2[ObjectAttributeType2["OBSERVER"] = 2] = "OBSERVER";
+  ObjectAttributeType2[ObjectAttributeType2["EVENT_LISTENER"] = 3] = "EVENT_LISTENER";
+  ObjectAttributeType2[ObjectAttributeType2["REFERENCE"] = 4] = "REFERENCE";
+  return ObjectAttributeType2;
+})(ObjectAttributeType || {});
+export {
+  ObjectAttributeType
+};

package/dist/helpers/camelToKebab.d.ts

@@ -0,0 +1 @@
+export declare const camelToKebabCase: (input: string) => string;

package/dist/helpers/camelToKebab.mjs

@@ -0,0 +1,7 @@
+// src/helpers/camelToKebab.ts
+var camelToKebabCase = (input) => {
+  return input.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+};
+export {
+  camelToKebabCase
+};

package/dist/server/createReference.d.ts

@@ -0,0 +1,6 @@
+import { ObjectAttributeType } from "../helpers/ObjectAttributeType";
+export declare const getReference: (ref: number) => Element | null;
+export declare const createReference: () => {
+    type: ObjectAttributeType;
+    value: number;
+};

package/dist/server/createReference.mjs

@@ -0,0 +1,18 @@
+// src/server/createReference.ts
+if (!globalThis.__SERVER_CURRENT_REF_ID__) {
+  globalThis.__SERVER_CURRENT_REF_ID__ = 0;
+}
+var currentRefId = globalThis.__SERVER_CURRENT_REF_ID__;
+var getReference = (ref) => {
+  return document.querySelector(`[ref="${ref}]"`);
+};
+var createReference = () => {
+  return {
+    type: 4 /* REFERENCE */,
+    value: currentRefId++
+  };
+};
+export {
+  createReference,
+  getReference
+};

package/dist/server/createState.d.ts

@@ -0,0 +1,47 @@
+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 createState: <U extends number | string | boolean | {}>(value: U, options?: {
+    bind?: number;
+}) => {
+    id: number;
+    value: Widen<U>;
+    type: ObjectAttributeType.STATE;
+    bind: string | undefined;
+};
+type Dependencies = {
+    type: ObjectAttributeType;
+    value: unknown;
+    id: number;
+    bind?: string;
+}[];
+type Parameters = {};
+export type SetEvent<E, CT> = Omit<Parameters, "event"> & {
+    event: Omit<E, "currentTarget"> & {
+        currentTarget: CT;
+    };
+};
+export type CreateEventListenerOptions<D extends Dependencies, P extends {} = {}> = {
+    dependencies?: [...D] | [];
+    eventListener: (params: P & {
+        event: Event;
+    }, ...subjects: {
+        [K in keyof D]: ClientSubjectGeneric<D[K]["value"]>;
+    }) => void;
+    params?: P | null;
+};
+export declare const createEventListener: <D extends Dependencies, P extends Parameters>({ eventListener, dependencies, params, }: CreateEventListenerOptions<D, P>) => {
+    id: number;
+    type: ObjectAttributeType;
+    value: Function;
+};
+export declare const initializeState: () => never[];
+export declare const getState: () => {
+    value: unknown;
+    type: ObjectAttributeType;
+    id: number;
+    bind?: number;
+}[];
+export {};

package/dist/server/createState.mjs

@@ -0,0 +1,50 @@
+// src/server/createState.ts
+if (!globalThis.__SERVER_CURRENT_STATE_ID__) {
+  globalThis.__SERVER_CURRENT_STATE_ID__ = 0;
+}
+var currentId = globalThis.__SERVER_CURRENT_STATE_ID__;
+var createState = (value, options) => {
+  const serverStateEntry = {
+    id: currentId += 1,
+    value,
+    type: 1 /* STATE */,
+    bind: options?.bind
+  };
+  globalThis.__SERVER_CURRENT_STATE__.push(serverStateEntry);
+  return serverStateEntry;
+};
+var createEventListener = ({
+  eventListener,
+  dependencies = [],
+  params
+}) => {
+  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: currentId += 1,
+    type: 1 /* STATE */,
+    value: new Function(
+      "state",
+      "event",
+      `(${eventListener.toString()})({ event, ...${JSON.stringify(params || {})} }, ...state.getAll(${dependencyString}))`
+    )
+  };
+  globalThis.__SERVER_CURRENT_STATE__.push(value);
+  return value;
+};
+var initializeState = () => globalThis.__SERVER_CURRENT_STATE__ = [];
+var getState = () => {
+  return globalThis.__SERVER_CURRENT_STATE__;
+};
+export {
+  createEventListener,
+  createState,
+  getState,
+  initializeState
+};

package/dist/server/generateHTMLTemplate.d.ts

@@ -0,0 +1,7 @@
+export declare const generateHTMLTemplate: ({ pageURL, head, serverData, addPageScriptTag, name, }: {
+    addPageScriptTag: boolean;
+    pageURL: string;
+    head: () => BuiltElement<"head">;
+    serverData?: string | null;
+    name: string;
+}) => string;