@pajh/buldng 0.0.4 → 0.0.6

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/src/buldng-ops.js

@@ -5,7 +5,7 @@ import fs from "node:fs";
 import path from "node:path";
 import esbuild from "esbuild";
 
-import { assertSourceRead, assertDestWrite, looksLikeFilename, ensureWorkFile } from "./buldng-validate.js";
+import { assertSourceRead, assertDestWrite, trackInput, looksLikeFilename, ensureWorkFile } from "./buldng-validate.js";
 export const OPS = {
     file: op_file,
     literal: op_literal,
@@ -107,10 +107,13 @@ export function op_compile(config, children) {
         const result = esbuild.buildSync({
             entryPoints: [entry],
             bundle: true,
+            metafile: true,
             ...compileOptions,
             write: false
         });
 
+        trackEsbuildInputs(result);
+
         if (result.errors?.length) {
             throw new Error("Build failed:\n" + result.errors.map(e => e.text).join("\n"));
         }
@@ -121,16 +124,19 @@ export function op_compile(config, children) {
     // Otherwise compile from stdin
     const srcText = child.execute();
 
-    const result = esbuild.buildSync({
+        const result = esbuild.buildSync({
         stdin: {
             contents: srcText,
             resolveDir: process.cwd(),
             sourcefile: "input.ts"
         },
-        bundle: true,
-        ...compileOptions,
-        write: false
-    });
+            bundle: true,
+            metafile: true,
+            ...compileOptions,
+            write: false
+        });
+
+        trackEsbuildInputs(result);
 
     if (result.errors?.length) {
         throw new Error("Build failed:\n" + result.errors.map(e => e.text).join("\n"));
@@ -139,6 +145,15 @@ export function op_compile(config, children) {
     return result.outputFiles[0].text;
 }
 
+function trackEsbuildInputs(result) {
+    for (const input of Object.keys(result.metafile?.inputs ?? {})) {
+        const abs = path.resolve(input);
+        if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+            trackInput(abs);
+        }
+    }
+}
+
 // --------------------------------------------------
 // MATERIALISE — write file if identical or new
 // --------------------------------------------------

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-validate.js

@@ -158,10 +158,17 @@ export function getInputs() {
 }
 
 export function trackInput(absPath) {
-  if (!SRC || !DEST) return;
-  if (absPath.startsWith(SRC) && !absPath.startsWith(DEST)) {
-    INPUTS.add(absPath);
+  const abs = path.resolve(absPath);
+
+  if (DEST) {
+    const relativeToDest = path.relative(DEST, abs);
+    const isInsideDest = relativeToDest === "" ||
+      (!relativeToDest.startsWith("..") && !path.isAbsolute(relativeToDest));
+
+    if (isInsideDest) return;
   }
+
+  INPUTS.add(abs);
 }
 
 export function looksLikeFilename(s) {
@@ -204,4 +211,4 @@ export function ensureWorkFile(x, fieldName = "value") {
   }
 
   throw new Error(`${fieldName} must be WorkFile or string`);
-}
+}