tannijs 0.1.1 → 0.1.3

package/dist/chunk-B42XHE7V.js

@@ -0,0 +1,318 @@
+// src/reactivity.ts
+var Signal = class {
+  constructor(value) {
+    this.value = value;
+  }
+  subscribers = /* @__PURE__ */ new Set();
+  read() {
+    trackDependency(this);
+    return this.value;
+  }
+  peek() {
+    return this.value;
+  }
+  write(next) {
+    if (Object.is(this.value, next)) {
+      return this.value;
+    }
+    this.value = next;
+    notifySubscribers(this.subscribers);
+    return this.value;
+  }
+};
+var Memo = class {
+  constructor(fn) {
+    this.fn = fn;
+    this.execute();
+  }
+  subscribers = /* @__PURE__ */ new Set();
+  deps = /* @__PURE__ */ new Set();
+  cleanups = [];
+  value;
+  read() {
+    trackDependency(this);
+    return this.value;
+  }
+  execute() {
+    cleanupComputation(this);
+    const previous = currentComputation;
+    currentComputation = this;
+    let nextValue;
+    try {
+      nextValue = this.fn();
+    } finally {
+      currentComputation = previous;
+    }
+    if (!Object.is(nextValue, this.value)) {
+      this.value = nextValue;
+      notifySubscribers(this.subscribers);
+    }
+  }
+};
+var pendingComputations = /* @__PURE__ */ new Set();
+var batchDepth = 0;
+var currentComputation = null;
+function trackDependency(source) {
+  if (!currentComputation) {
+    return;
+  }
+  source.subscribers.add(currentComputation);
+  currentComputation.deps.add(source);
+}
+function cleanupComputation(computation) {
+  for (const source of computation.deps) {
+    source.subscribers.delete(computation);
+  }
+  computation.deps.clear();
+  const cleanups = computation.cleanups;
+  computation.cleanups = [];
+  for (const cleanup of cleanups) {
+    cleanup();
+  }
+}
+function runComputation(computation) {
+  if (batchDepth > 0) {
+    pendingComputations.add(computation);
+    return;
+  }
+  computation.execute();
+}
+function notifySubscribers(subscribers) {
+  const queue = Array.from(subscribers);
+  for (const subscriber of queue) {
+    runComputation(subscriber);
+  }
+}
+function flushPending() {
+  if (pendingComputations.size === 0) {
+    return;
+  }
+  const queue = Array.from(pendingComputations);
+  pendingComputations.clear();
+  for (const computation of queue) {
+    computation.execute();
+  }
+  if (pendingComputations.size > 0) {
+    flushPending();
+  }
+}
+function createSignal(initialValue) {
+  const signal = new Signal(initialValue);
+  const accessor = () => signal.read();
+  const setter = (value) => {
+    const nextValue = typeof value === "function" ? value(signal.peek()) : value;
+    return signal.write(nextValue);
+  };
+  return [accessor, setter];
+}
+function createEffect(fn) {
+  const effect2 = {
+    deps: /* @__PURE__ */ new Set(),
+    cleanups: [],
+    execute() {
+      cleanupComputation(effect2);
+      const previous = currentComputation;
+      currentComputation = effect2;
+      try {
+        fn();
+      } finally {
+        currentComputation = previous;
+      }
+    }
+  };
+  effect2.execute();
+}
+function createMemo(fn) {
+  const memo = new Memo(fn);
+  return () => memo.read();
+}
+function batch(fn) {
+  batchDepth += 1;
+  try {
+    return fn();
+  } finally {
+    batchDepth -= 1;
+    if (batchDepth === 0) {
+      flushPending();
+    }
+  }
+}
+function untrack(fn) {
+  const previous = currentComputation;
+  currentComputation = null;
+  try {
+    return fn();
+  } finally {
+    currentComputation = previous;
+  }
+}
+function onCleanup(fn) {
+  if (!currentComputation) {
+    throw new Error("onCleanup must be called inside a tracked computation.");
+  }
+  currentComputation.cleanups.push(fn);
+}
+function onMount(fn) {
+  queueMicrotask(fn);
+}
+var effect = createEffect;
+
+// src/dom.ts
+var delegatedEvents = /* @__PURE__ */ new Set();
+var listeningEvents = /* @__PURE__ */ new Set();
+var directListeners = /* @__PURE__ */ new WeakMap();
+function template(html) {
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html.trim();
+  if (tpl.content.childNodes.length === 1) {
+    return tpl.content.firstChild;
+  }
+  return tpl.content;
+}
+function insert(parent, value, marker = null) {
+  if (typeof value === "function") {
+    let currentNodes = [];
+    createEffect(() => {
+      const resolved = value();
+      const nextNodes2 = normalizeNodes(resolved);
+      currentNodes = replaceNodes(parent, currentNodes, nextNodes2, marker);
+    });
+    return;
+  }
+  const nextNodes = normalizeNodes(value);
+  replaceNodes(parent, [], nextNodes, marker);
+}
+function spread(element, props) {
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children") {
+      insert(element, value);
+      continue;
+    }
+    if (key === "style" && value && typeof value === "object") {
+      Object.assign(element.style, value);
+      continue;
+    }
+    const eventName = toEventName(key);
+    if (eventName) {
+      applyEventHandler(element, eventName, value);
+      continue;
+    }
+    applyProperty(element, key, value);
+  }
+}
+function delegateEvents(eventNames) {
+  for (const eventName of eventNames) {
+    const normalized = eventName.toLowerCase();
+    delegatedEvents.add(normalized);
+    if (listeningEvents.has(normalized)) {
+      continue;
+    }
+    listeningEvents.add(normalized);
+    document.addEventListener(normalized, handleDelegatedEvent);
+  }
+}
+function handleDelegatedEvent(event) {
+  const type = event.type.toLowerCase();
+  let node = event.target;
+  while (node && node !== document) {
+    if (node instanceof Element) {
+      const handlers = node.__tnDelegatedHandlers;
+      const handler = handlers?.[type];
+      if (handler) {
+        handler(event);
+        if (event.cancelBubble) {
+          return;
+        }
+      }
+    }
+    node = node.parentNode;
+  }
+}
+function applyEventHandler(element, eventName, value) {
+  if (typeof value !== "function") {
+    return;
+  }
+  const handler = value;
+  if (delegatedEvents.has(eventName)) {
+    const delegatedElement = element;
+    delegatedElement.__tnDelegatedHandlers ??= {};
+    delegatedElement.__tnDelegatedHandlers[eventName] = handler;
+    return;
+  }
+  let listenersForElement = directListeners.get(element);
+  if (!listenersForElement) {
+    listenersForElement = /* @__PURE__ */ new Map();
+    directListeners.set(element, listenersForElement);
+  }
+  const previous = listenersForElement.get(eventName);
+  if (previous) {
+    element.removeEventListener(eventName, previous);
+  }
+  listenersForElement.set(eventName, handler);
+  element.addEventListener(eventName, handler);
+}
+function applyProperty(element, key, value) {
+  const writableElement = element;
+  if (value === false || value == null) {
+    element.removeAttribute(key);
+    if (key in element) {
+      writableElement[key] = "";
+    }
+    return;
+  }
+  if (key in element && !key.startsWith("aria-") && !key.startsWith("data-")) {
+    writableElement[key] = value;
+    return;
+  }
+  element.setAttribute(key, String(value));
+}
+function toEventName(key) {
+  if (key.startsWith("on:")) {
+    return key.slice(3).toLowerCase();
+  }
+  if (key.startsWith("@")) {
+    return key.slice(1).toLowerCase();
+  }
+  if (key.startsWith("on") && key.length > 2) {
+    return key.slice(2).toLowerCase();
+  }
+  return null;
+}
+function normalizeNodes(value) {
+  if (value == null || value === false || value === true) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => normalizeNodes(entry));
+  }
+  if (value instanceof Node) {
+    return [value];
+  }
+  return [document.createTextNode(String(value))];
+}
+function replaceNodes(parent, currentNodes, nextNodes, marker) {
+  for (const node of currentNodes) {
+    if (node.parentNode === parent) {
+      parent.removeChild(node);
+    }
+  }
+  for (const node of nextNodes) {
+    parent.insertBefore(node, marker);
+  }
+  return nextNodes;
+}
+
+export {
+  createSignal,
+  createEffect,
+  createMemo,
+  batch,
+  untrack,
+  onCleanup,
+  onMount,
+  effect,
+  template,
+  insert,
+  spread,
+  delegateEvents
+};

package/dist/index.d.ts

@@ -7,5 +7,13 @@ declare function createMemo<T>(fn: () => T): Accessor<T>;
 declare function batch<T>(fn: () => T): T;
 declare function untrack<T>(fn: () => T): T;
 declare function onCleanup(fn: CleanupFn): void;
+declare function onMount(fn: () => void): void;
+declare const effect: typeof createEffect;
 
-export { type Accessor, type Setter, batch, createEffect, createMemo, createSignal, onCleanup, untrack };
+type InsertValue = Node | string | number | boolean | null | undefined | InsertValue[] | (() => InsertValue);
+declare function template(html: string): Node;
+declare function insert(parent: Node, value: InsertValue, marker?: Node | null): void;
+declare function spread(element: Element, props: Record<string, unknown>): void;
+declare function delegateEvents(eventNames: string[]): void;
+
+export { type Accessor, type InsertValue, type Setter, batch, createEffect, createMemo, createSignal, delegateEvents, effect, insert, onCleanup, onMount, spread, template, untrack };

package/dist/index.js

@@ -3,14 +3,26 @@ import {
   createEffect,
   createMemo,
   createSignal,
+  delegateEvents,
+  effect,
+  insert,
   onCleanup,
+  onMount,
+  spread,
+  template,
   untrack
-} from "./chunk-GQWZEFRY.js";
+} from "./chunk-B42XHE7V.js";
 export {
   batch,
   createEffect,
   createMemo,
   createSignal,
+  delegateEvents,
+  effect,
+  insert,
   onCleanup,
+  onMount,
+  spread,
+  template,
   untrack
 };

package/dist/internals.d.ts

@@ -1,9 +1 @@
-export { createEffect } from './index.js';
-
-type InsertValue = Node | string | number | boolean | null | undefined | InsertValue[] | (() => InsertValue);
-declare function template(html: string): Node;
-declare function insert(parent: Node, value: InsertValue, marker?: Node | null): void;
-declare function spread(element: Element, props: Record<string, unknown>): void;
-declare function delegateEvents(eventNames: string[]): void;
-
-export { type InsertValue, delegateEvents, insert, spread, template };
+export { InsertValue, createEffect, delegateEvents, insert, spread, template } from './index.js';

package/dist/internals.js

@@ -1,151 +1,10 @@
 import {
-  createEffect
-} from "./chunk-GQWZEFRY.js";
-
-// src/dom.ts
-var delegatedEvents = /* @__PURE__ */ new Set();
-var listeningEvents = /* @__PURE__ */ new Set();
-var directListeners = /* @__PURE__ */ new WeakMap();
-function template(html) {
-  const tpl = document.createElement("template");
-  tpl.innerHTML = html.trim();
-  if (tpl.content.childNodes.length === 1) {
-    return tpl.content.firstChild;
-  }
-  return tpl.content;
-}
-function insert(parent, value, marker = null) {
-  if (typeof value === "function") {
-    let currentNodes = [];
-    createEffect(() => {
-      const resolved = value();
-      const nextNodes2 = normalizeNodes(resolved);
-      currentNodes = replaceNodes(parent, currentNodes, nextNodes2, marker);
-    });
-    return;
-  }
-  const nextNodes = normalizeNodes(value);
-  replaceNodes(parent, [], nextNodes, marker);
-}
-function spread(element, props) {
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children") {
-      insert(element, value);
-      continue;
-    }
-    if (key === "style" && value && typeof value === "object") {
-      Object.assign(element.style, value);
-      continue;
-    }
-    const eventName = toEventName(key);
-    if (eventName) {
-      applyEventHandler(element, eventName, value);
-      continue;
-    }
-    applyProperty(element, key, value);
-  }
-}
-function delegateEvents(eventNames) {
-  for (const eventName of eventNames) {
-    const normalized = eventName.toLowerCase();
-    delegatedEvents.add(normalized);
-    if (listeningEvents.has(normalized)) {
-      continue;
-    }
-    listeningEvents.add(normalized);
-    document.addEventListener(normalized, handleDelegatedEvent);
-  }
-}
-function handleDelegatedEvent(event) {
-  const type = event.type.toLowerCase();
-  let node = event.target;
-  while (node && node !== document) {
-    if (node instanceof Element) {
-      const handlers = node.__tnDelegatedHandlers;
-      const handler = handlers?.[type];
-      if (handler) {
-        handler(event);
-        if (event.cancelBubble) {
-          return;
-        }
-      }
-    }
-    node = node.parentNode;
-  }
-}
-function applyEventHandler(element, eventName, value) {
-  if (typeof value !== "function") {
-    return;
-  }
-  const handler = value;
-  if (delegatedEvents.has(eventName)) {
-    const delegatedElement = element;
-    delegatedElement.__tnDelegatedHandlers ??= {};
-    delegatedElement.__tnDelegatedHandlers[eventName] = handler;
-    return;
-  }
-  let listenersForElement = directListeners.get(element);
-  if (!listenersForElement) {
-    listenersForElement = /* @__PURE__ */ new Map();
-    directListeners.set(element, listenersForElement);
-  }
-  const previous = listenersForElement.get(eventName);
-  if (previous) {
-    element.removeEventListener(eventName, previous);
-  }
-  listenersForElement.set(eventName, handler);
-  element.addEventListener(eventName, handler);
-}
-function applyProperty(element, key, value) {
-  const writableElement = element;
-  if (value === false || value == null) {
-    element.removeAttribute(key);
-    if (key in element) {
-      writableElement[key] = "";
-    }
-    return;
-  }
-  if (key in element && !key.startsWith("aria-") && !key.startsWith("data-")) {
-    writableElement[key] = value;
-    return;
-  }
-  element.setAttribute(key, String(value));
-}
-function toEventName(key) {
-  if (key.startsWith("on:")) {
-    return key.slice(3).toLowerCase();
-  }
-  if (key.startsWith("@")) {
-    return key.slice(1).toLowerCase();
-  }
-  if (key.startsWith("on") && key.length > 2) {
-    return key.slice(2).toLowerCase();
-  }
-  return null;
-}
-function normalizeNodes(value) {
-  if (value == null || value === false || value === true) {
-    return [];
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry) => normalizeNodes(entry));
-  }
-  if (value instanceof Node) {
-    return [value];
-  }
-  return [document.createTextNode(String(value))];
-}
-function replaceNodes(parent, currentNodes, nextNodes, marker) {
-  for (const node of currentNodes) {
-    if (node.parentNode === parent) {
-      parent.removeChild(node);
-    }
-  }
-  for (const node of nextNodes) {
-    parent.insertBefore(node, marker);
-  }
-  return nextNodes;
-}
+  createEffect,
+  delegateEvents,
+  insert,
+  spread,
+  template
+} from "./chunk-B42XHE7V.js";
 export {
   createEffect,
   delegateEvents,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tannijs",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Signal-based reactive runtime for the Tanni framework",
   "license": "MIT",

package/dist/chunk-GQWZEFRY.js

@@ -1,163 +0,0 @@
-// src/reactivity.ts
-var Signal = class {
-  constructor(value) {
-    this.value = value;
-  }
-  subscribers = /* @__PURE__ */ new Set();
-  read() {
-    trackDependency(this);
-    return this.value;
-  }
-  peek() {
-    return this.value;
-  }
-  write(next) {
-    if (Object.is(this.value, next)) {
-      return this.value;
-    }
-    this.value = next;
-    notifySubscribers(this.subscribers);
-    return this.value;
-  }
-};
-var Memo = class {
-  constructor(fn) {
-    this.fn = fn;
-    this.execute();
-  }
-  subscribers = /* @__PURE__ */ new Set();
-  deps = /* @__PURE__ */ new Set();
-  cleanups = [];
-  value;
-  read() {
-    trackDependency(this);
-    return this.value;
-  }
-  execute() {
-    cleanupComputation(this);
-    const previous = currentComputation;
-    currentComputation = this;
-    let nextValue;
-    try {
-      nextValue = this.fn();
-    } finally {
-      currentComputation = previous;
-    }
-    if (!Object.is(nextValue, this.value)) {
-      this.value = nextValue;
-      notifySubscribers(this.subscribers);
-    }
-  }
-};
-var pendingComputations = /* @__PURE__ */ new Set();
-var batchDepth = 0;
-var currentComputation = null;
-function trackDependency(source) {
-  if (!currentComputation) {
-    return;
-  }
-  source.subscribers.add(currentComputation);
-  currentComputation.deps.add(source);
-}
-function cleanupComputation(computation) {
-  for (const source of computation.deps) {
-    source.subscribers.delete(computation);
-  }
-  computation.deps.clear();
-  const cleanups = computation.cleanups;
-  computation.cleanups = [];
-  for (const cleanup of cleanups) {
-    cleanup();
-  }
-}
-function runComputation(computation) {
-  if (batchDepth > 0) {
-    pendingComputations.add(computation);
-    return;
-  }
-  computation.execute();
-}
-function notifySubscribers(subscribers) {
-  const queue = Array.from(subscribers);
-  for (const subscriber of queue) {
-    runComputation(subscriber);
-  }
-}
-function flushPending() {
-  if (pendingComputations.size === 0) {
-    return;
-  }
-  const queue = Array.from(pendingComputations);
-  pendingComputations.clear();
-  for (const computation of queue) {
-    computation.execute();
-  }
-  if (pendingComputations.size > 0) {
-    flushPending();
-  }
-}
-function createSignal(initialValue) {
-  const signal = new Signal(initialValue);
-  const accessor = () => signal.read();
-  const setter = (value) => {
-    const nextValue = typeof value === "function" ? value(signal.peek()) : value;
-    return signal.write(nextValue);
-  };
-  return [accessor, setter];
-}
-function createEffect(fn) {
-  const effect = {
-    deps: /* @__PURE__ */ new Set(),
-    cleanups: [],
-    execute() {
-      cleanupComputation(effect);
-      const previous = currentComputation;
-      currentComputation = effect;
-      try {
-        fn();
-      } finally {
-        currentComputation = previous;
-      }
-    }
-  };
-  effect.execute();
-}
-function createMemo(fn) {
-  const memo = new Memo(fn);
-  return () => memo.read();
-}
-function batch(fn) {
-  batchDepth += 1;
-  try {
-    return fn();
-  } finally {
-    batchDepth -= 1;
-    if (batchDepth === 0) {
-      flushPending();
-    }
-  }
-}
-function untrack(fn) {
-  const previous = currentComputation;
-  currentComputation = null;
-  try {
-    return fn();
-  } finally {
-    currentComputation = previous;
-  }
-}
-function onCleanup(fn) {
-  if (!currentComputation) {
-    throw new Error("onCleanup must be called inside a tracked computation.");
-  }
-  currentComputation.cleanups.push(fn);
-}
-
-export {
-  createSignal,
-  createEffect,
-  createMemo,
-  batch,
-  untrack,
-  onCleanup
-};