@pajh/buldng 0.0.3 → 0.0.5

package/src/buldng-modal.ts

@@ -0,0 +1,348 @@
+export type ModalType =
+  | "info"
+  | "confirmation"
+  | "destructive"
+  | "error";
+
+export type ModalIcon = "info" | "warning" | "error" | null;
+
+export type ModalResult = "ok" | "cancel" | "dismiss";
+
+export interface ModalSettings {
+  title?: string;
+  icon?: ModalIcon;
+  autoDismiss?: number;
+  dismissOnEsc?: boolean;
+  dismissOnBackdrop?: boolean;
+}
+
+const MODAL_ROOT_ID = "b-modal-root";
+let modalId = 0;
+
+interface ModalRoot {
+  element: HTMLElement;
+  created: boolean;
+}
+
+function getModalRoot(): ModalRoot {
+  const existingRoot = document.getElementById(MODAL_ROOT_ID);
+  if (existingRoot instanceof HTMLElement) {
+    return { element: existingRoot, created: false };
+  }
+
+  const createdRoot = document.createElement("div");
+  createdRoot.id = MODAL_ROOT_ID;
+  document.body.appendChild(createdRoot);
+  return { element: createdRoot, created: true };
+}
+
+function getIconText(icon: ModalIcon): string {
+  if (icon === "info") {
+    return "i";
+  }
+  if (icon === "warning") {
+    return "!";
+  }
+  if (icon === "error") {
+    return "!";
+  }
+  return "";
+}
+
+function getDefaultIcon(type: ModalType): ModalIcon {
+  if (type === "destructive") {
+    return "warning";
+  }
+  if (type === "error") {
+    return "error";
+  }
+  return null;
+}
+
+function getButtonLabels(type: ModalType): { primary: string; secondary: string | null } {
+  if (type === "confirmation") {
+    return { primary: "OK", secondary: "Cancel" };
+  }
+  if (type === "destructive") {
+    return { primary: "Delete", secondary: "Cancel" };
+  }
+  return { primary: "OK", secondary: null };
+}
+
+function getDefaultDismissal(type: ModalType): boolean {
+  return type !== "destructive";
+}
+
+function getInitialFocus(dialog: HTMLElement, primaryButton: HTMLButtonElement): HTMLElement {
+  const focusable = dialog.querySelector<HTMLElement>(
+    "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])"
+  );
+  if (focusable !== null) {
+    return focusable;
+  }
+  return primaryButton;
+}
+
+function isInsideDialog(target: EventTarget | null, dialog: HTMLElement): boolean {
+  return target instanceof Node && dialog.contains(target);
+}
+
+class ModalController {
+  private readonly type: ModalType;
+  private readonly content: string;
+  private readonly settings: ModalSettings;
+  private readonly root: HTMLElement;
+  private readonly ownsRoot: boolean;
+  private readonly previousFocus: HTMLElement | null;
+  private readonly dialog: HTMLElement;
+  private readonly backdrop: HTMLElement;
+  private readonly primaryButton: HTMLButtonElement;
+  private readonly secondaryButton: HTMLButtonElement | null;
+  private readonly keydownHandler: (event: KeyboardEvent) => void;
+  private timeoutId: number | null;
+  private settled: boolean;
+  private resolveResult: ((result: ModalResult) => void) | null;
+
+  public constructor(
+    type: ModalType,
+    content: string,
+    settings: ModalSettings
+  ) {
+    this.type = type;
+    this.content = content;
+    this.settings = settings;
+    const modalRoot = getModalRoot();
+    this.root = modalRoot.element;
+    this.ownsRoot = modalRoot.created;
+    this.previousFocus = document.activeElement instanceof HTMLElement
+      ? document.activeElement
+      : null;
+    this.dialog = this.createDialog();
+    this.backdrop = this.createBackdrop();
+    this.primaryButton = this.createPrimaryButton();
+    this.secondaryButton = this.createSecondaryButton();
+    this.addHeader();
+    this.addContent();
+    this.addFooter();
+    this.timeoutId = null;
+    this.settled = false;
+    this.resolveResult = null;
+    this.keydownHandler = (event: KeyboardEvent) => {
+      this.handleKeydown(event);
+    };
+  }
+
+  public open(): Promise<ModalResult> {
+    this.root.appendChild(this.backdrop);
+    this.backdrop.appendChild(this.dialog);
+    this.registerListeners();
+
+    const initialFocus = getInitialFocus(this.dialog, this.primaryButton);
+    initialFocus.focus();
+
+    if (this.settings.autoDismiss !== undefined && this.settings.autoDismiss > 0) {
+      this.timeoutId = window.setTimeout(() => {
+        this.finish("dismiss");
+      }, this.settings.autoDismiss);
+    }
+
+    return new Promise<ModalResult>((resolve) => {
+      this.resolveResult = resolve;
+    });
+  }
+
+  private createDialog(): HTMLElement {
+    const dialog = document.createElement("div");
+    dialog.className = `buldng-modal ${this.type}`;
+    dialog.setAttribute("role", "dialog");
+    dialog.setAttribute("aria-modal", "true");
+    dialog.tabIndex = -1;
+    return dialog;
+  }
+
+  private createBackdrop(): HTMLElement {
+    const backdrop = document.createElement("div");
+    backdrop.className = "buldng-modal-backdrop";
+    backdrop.setAttribute("aria-hidden", "true");
+    return backdrop;
+  }
+
+  private createPrimaryButton(): HTMLButtonElement {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "buldng-modal-button buldng-modal-button-primary";
+    button.textContent = getButtonLabels(this.type).primary;
+    return button;
+  }
+
+  private createSecondaryButton(): HTMLButtonElement | null {
+    const labels = getButtonLabels(this.type);
+    if (labels.secondary === null) {
+      return null;
+    }
+
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "buldng-modal-button buldng-modal-button-secondary";
+    button.textContent = labels.secondary;
+    return button;
+  }
+
+  private addHeader(): void {
+    const hasTitle = this.settings.title !== undefined && this.settings.title.length > 0;
+    const icon = this.settings.icon === undefined
+      ? getDefaultIcon(this.type)
+      : this.settings.icon;
+    const hasIcon = icon !== null;
+
+    if (!hasTitle && !hasIcon) {
+      return;
+    }
+
+    const header = document.createElement("div");
+    header.className = "buldng-modal-header";
+
+    if (hasIcon) {
+      const iconElement = document.createElement("span");
+      iconElement.className = "buldng-modal-icon";
+      iconElement.setAttribute("aria-hidden", "true");
+      iconElement.textContent = getIconText(icon);
+      header.appendChild(iconElement);
+    }
+
+    if (hasTitle) {
+      const title = document.createElement("h2");
+      title.className = "buldng-modal-title";
+      title.textContent = this.settings.title as string;
+      modalId += 1;
+      const titleId = `buldng-modal-title-${modalId}`;
+      title.id = titleId;
+      this.dialog.setAttribute("aria-labelledby", titleId);
+      header.appendChild(title);
+      this.dialog.appendChild(header);
+      return;
+    }
+
+    this.dialog.appendChild(header);
+  }
+
+  private addContent(): void {
+    const content = document.createElement("div");
+    content.className = "buldng-modal-content";
+    content.innerHTML = this.content;
+    this.dialog.appendChild(content);
+  }
+
+  private addFooter(): void {
+    const footer = document.createElement("div");
+    footer.className = "buldng-modal-footer";
+
+    if (this.secondaryButton !== null) {
+      footer.appendChild(this.secondaryButton);
+    }
+    footer.appendChild(this.primaryButton);
+    this.dialog.appendChild(footer);
+  }
+
+  private registerListeners(): void {
+    this.primaryButton.addEventListener("click", () => {
+      this.finish("ok");
+    });
+
+    if (this.secondaryButton !== null) {
+      this.secondaryButton.addEventListener("click", () => {
+        this.finish("cancel");
+      });
+    }
+
+    this.backdrop.addEventListener("click", (event: MouseEvent) => {
+      if (isInsideDialog(event.target, this.dialog)) {
+        return;
+      }
+      const dismissOnBackdrop = this.settings.dismissOnBackdrop === undefined
+        ? getDefaultDismissal(this.type)
+        : this.settings.dismissOnBackdrop;
+      if (dismissOnBackdrop === true) {
+        this.finish("dismiss");
+      }
+    });
+
+    document.addEventListener("keydown", this.keydownHandler);
+  }
+
+  private handleKeydown(event: KeyboardEvent): void {
+    if (event.key === "Escape") {
+      const dismissOnEsc = this.settings.dismissOnEsc === undefined
+        ? getDefaultDismissal(this.type)
+        : this.settings.dismissOnEsc;
+      if (dismissOnEsc === true) {
+        event.preventDefault();
+        this.finish("dismiss");
+      }
+      return;
+    }
+
+    if (event.key === "Tab") {
+      this.keepFocusInside(event);
+    }
+  }
+
+  private keepFocusInside(event: KeyboardEvent): void {
+    const focusable = Array.from(this.dialog.querySelectorAll<HTMLElement>(
+      "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])"
+    ));
+    if (focusable.length === 0) {
+      event.preventDefault();
+      this.dialog.focus();
+      return;
+    }
+
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+
+    if (event.shiftKey === true && active === first) {
+      event.preventDefault();
+      last.focus();
+    } else if (event.shiftKey === false && active === last) {
+      event.preventDefault();
+      first.focus();
+    }
+  }
+
+  private finish(result: ModalResult): void {
+    if (this.settled === true) {
+      return;
+    }
+    this.settled = true;
+
+    if (this.timeoutId !== null) {
+      window.clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+
+    document.removeEventListener("keydown", this.keydownHandler);
+    this.backdrop.remove();
+    if (this.ownsRoot === true && this.root.childElementCount === 0) {
+      this.root.remove();
+    }
+
+    if (this.previousFocus !== null && document.contains(this.previousFocus)) {
+      this.previousFocus.focus();
+    }
+
+    if (this.resolveResult !== null) {
+      this.resolveResult(result);
+      this.resolveResult = null;
+    }
+  }
+}
+
+export function showModal(
+  type: ModalType,
+  content: string,
+  settings: ModalSettings = {}
+): Promise<ModalResult> {
+  const controller = new ModalController(type, content, settings);
+  return controller.open();
+}

package/{dist → src}/buldng-ops.js

@@ -93,6 +93,12 @@ export function op_compile(config, children) {
     }
 
     const child = children[0];
+    const compileOptions = {
+        minify: config.flags?.minify ?? true,
+        sourcemap: config.flags?.sourcemap ?? true,
+        format: config.flags?.format ?? "esm",
+        target: config.flags?.target ?? "esnext",
+    };
 
     // If child is a file WorkFile, use its absolute path directly
     if (child.op === "file" && child.config.absPath) {
@@ -101,10 +107,7 @@ export function op_compile(config, children) {
         const result = esbuild.buildSync({
             entryPoints: [entry],
             bundle: true,
-            minify: true,
-            sourcemap: true,
-            format: "esm",
-            target: "esnext",
+            ...compileOptions,
             write: false
         });
 
@@ -125,10 +128,7 @@ export function op_compile(config, children) {
             sourcefile: "input.ts"
         },
         bundle: true,
-        minify: true,
-        sourcemap: true,
-        format: "esm",
-        target: "esnext",
+        ...compileOptions,
         write: false
     });
 

package/src/buldng-typescript.js

@@ -0,0 +1,77 @@
+// buldng-typescript.js
+// typescript build support for buldng
+// 
+
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { execSync } from "child_process";
+
+function findTSCFromResolved(tsPath) {
+    // tsPath → /.../typescript/lib/typescript.js
+    let dir = path.dirname(tsPath);      // /.../typescript/lib
+    dir = path.dirname(dir);             // /.../typescript
+
+    while (true) {
+        const candidate = path.join(dir, ".bin", "tsc");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+
+        const parent = path.dirname(dir);
+        if (parent === dir) break;       // reached filesystem root
+        dir = parent;
+    }
+
+    return null;
+}
+
+function findGlobalTSC() {
+    try {
+        const globalTSC = execSync("which tsc").toString().trim();
+        return globalTSC || null;
+    } catch {
+        return null;
+    }
+}
+
+export function typescriptCheck() {
+    const require = createRequire(import.meta.url);
+
+    let tsPath = null;
+
+    try {
+        tsPath = require.resolve("typescript");
+    } catch {
+        tsPath = null;
+    }
+
+    let tscPath = null;
+
+    if (tsPath) {
+        // Local / nested / linked TypeScript
+        tscPath = findTSCFromResolved(tsPath);
+    } else {
+        // Try global TypeScript
+        tscPath = findGlobalTSC();
+    }
+
+    if (!tscPath) {
+        console.log("TypeScript not found — skipping TS checks");
+        return;
+    }
+
+    console.log("Using TypeScript compiler:", tscPath);
+
+    try {
+        execSync(`${tscPath} --noEmit`, { stdio: "inherit" });
+    } catch (err) {
+        // If tsc exists but cannot run → internal error
+        if (err.code === "ENOENT") {
+            throw new Error("Internal TypeScript error — 'tsc' binary exists but cannot be executed");
+        }
+
+        // If tsc runs but reports TS errors → build failure
+        throw new Error("TypeScript check failed");
+    }
+}

package/src/buldng-web.ts

@@ -0,0 +1,142 @@
+// buldng-web.ts
+// Runtime-only listener installer for BULDR.
+// This module contains NO production logic and NO module-level state.
+// It is safe to be bundled multiple times.
+
+export { showModal } from "./buldng-modal";
+export type {
+  ModalIcon,
+  ModalResult,
+  ModalSettings,
+  ModalType,
+} from "./buldng-modal";
+
+export function setErrorPage(page: string) {
+  if (typeof page !== "string" || !page.length) {
+    throw new Error("setErrorPage: page must be a non-empty string");
+  }
+
+  // Capture `page` in closure — NOT stored on window
+  window.addEventListener("error", (event) => {
+    window.__error_handler?.(event, page);
+  });
+
+  window.addEventListener("unhandledrejection", (event) => {
+    window.__error_handler?.(event, page);
+  });
+
+  console.log(`BULDR: Error handler listener installed, redirect ${page}`);
+
+}
+
+// ------------------------------------------------------------
+// ERROR PAGE SUPPORT — moved from layout-err.ts
+// ------------------------------------------------------------
+
+import type { ErrorPayload } from "./layout-err"; // or wherever you export it
+
+export function readErrorPayload(id: string | null): ErrorPayload | null {
+  if (!id) return null;
+
+  try {
+    const raw = localStorage.getItem(storageKey(id));
+    if (!raw) return null;
+
+    const payload: unknown = JSON.parse(raw);
+    return isErrorPayload(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+export function consumeErrorPayload(id: string | null): ErrorPayload | null {
+  const payload = readErrorPayload(id);
+  if (id) {
+    try {
+      localStorage.removeItem(storageKey(id));
+    } catch {}
+  }
+  return payload;
+}
+
+export function renderErrorPayload(
+  elementId: string,
+  payload: ErrorPayload | null
+): ErrorPayload | null {
+  const container = document.getElementById(elementId);
+  if (!container) return null;
+
+  container.replaceChildren();
+
+  if (!payload) {
+    const empty = document.createElement("p");
+    empty.textContent = "Error details are no longer available.";
+    container.appendChild(empty);
+    return null;
+  }
+
+  const details: Array<[string, string]> = [
+    ["Type", payload.type],
+    ["Message", payload.message],
+    ["Time", payload.time],
+    ["Page", payload.url],
+    ["User agent", payload.userAgent],
+    ["Platform", payload.platform],
+    ["Language", payload.language],
+  ];
+
+  const list = document.createElement("dl");
+
+  for (const [label, value] of details) {
+    const term = document.createElement("dt");
+    term.textContent = label;
+
+    const description = document.createElement("dd");
+    description.textContent = value;
+
+    list.append(term, description);
+  }
+
+  if (payload.stack) {
+    const stackLabel = document.createElement("h3");
+    stackLabel.textContent = "Stack";
+
+    const stack = document.createElement("pre");
+    stack.textContent = payload.stack;
+
+    list.append(stackLabel, stack);
+  }
+
+  container.appendChild(list);
+  return payload;
+}
+
+export function getErrorId(): string | null {
+  return new URLSearchParams(location.search).get("errorId");
+}
+
+// ------------------------------------------------------------
+// TYPE GUARDS & UTILITIES — also needed by error page
+// ------------------------------------------------------------
+
+function isErrorPayload(value: unknown): value is ErrorPayload {
+  if (!value || typeof value !== "object") return false;
+
+  const p = value as Partial<ErrorPayload>;
+
+  return (
+    typeof p.id === "string" &&
+    (p.type === "error" || p.type === "unhandledrejection") &&
+    typeof p.message === "string" &&
+    typeof p.stack === "string" &&
+    typeof p.time === "string" &&
+    typeof p.url === "string" &&
+    typeof p.userAgent === "string" &&
+    typeof p.platform === "string" &&
+    typeof p.language === "string"
+  );
+}
+
+function storageKey(id: string) {
+  return `buldng:error:${id}`;
+}