@oscarpalmer/abydon 0.11.0 → 0.13.0

package/types/node/index.d.cts

@@ -0,0 +1,108 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A generic key type
+ */
+export type Key = number | string;
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+}
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+	/**
+	 * Get the value
+	 */
+	abstract get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * JSON representation of the value
+	 */
+	toJSON(): Value;
+	/**
+	 * String representation of the value
+	 */
+	toString(): string;
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void;
+}
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+declare class Fragment {
+	private readonly $fragment;
+	private readonly data;
+	get identifier(): Key | undefined;
+	constructor(strings: TemplateStringsArray, expressions: unknown[]);
+	/**
+	 * Appends the fragment to the given element
+	 */
+	appendTo(element: Element): void;
+	/**
+	 * Gets a list of the fragment's nodes
+	 */
+	get(): ChildNode[];
+	identify(identifier: Key): Fragment;
+	/**
+	 * Removes the fragment from the DOM
+	 */
+	remove(): void;
+}
+export type FragmentData = {
+	expressions: unknown[];
+	identifier?: Key;
+	items: FragmentItem[];
+	mora: MoraData;
+	strings: TemplateStringsArray;
+	values: unknown[];
+};
+export type FragmentItem = {
+	fragments?: Fragment[];
+	nodes: ChildNode[];
+};
+export type MoraData = {
+	subscribers: Set<() => void>;
+	values: Set<Reactive<unknown>>;
+};
+export declare function mapNodes(data: FragmentData, nodes: ChildNode[]): void;
+
+export {};

package/types/node/index.d.ts

@@ -1,2 +1,2 @@
-import type { FragmentData, ProperNode } from '../models';
-export declare function mapNodes(data: FragmentData, nodes: ProperNode[]): void;
+import type { FragmentData } from '../models';
+export declare function mapNodes(data: FragmentData, nodes: ChildNode[]): void;

package/types/node/value.d.cts

@@ -0,0 +1,108 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A generic key type
+ */
+export type Key = number | string;
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+}
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+	/**
+	 * Get the value
+	 */
+	abstract get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * JSON representation of the value
+	 */
+	toJSON(): Value;
+	/**
+	 * String representation of the value
+	 */
+	toString(): string;
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void;
+}
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+declare class Fragment {
+	private readonly $fragment;
+	private readonly data;
+	get identifier(): Key | undefined;
+	constructor(strings: TemplateStringsArray, expressions: unknown[]);
+	/**
+	 * Appends the fragment to the given element
+	 */
+	appendTo(element: Element): void;
+	/**
+	 * Gets a list of the fragment's nodes
+	 */
+	get(): ChildNode[];
+	identify(identifier: Key): Fragment;
+	/**
+	 * Removes the fragment from the DOM
+	 */
+	remove(): void;
+}
+export type FragmentData = {
+	expressions: unknown[];
+	identifier?: Key;
+	items: FragmentItem[];
+	mora: MoraData;
+	strings: TemplateStringsArray;
+	values: unknown[];
+};
+export type FragmentItem = {
+	fragments?: Fragment[];
+	nodes: ChildNode[];
+};
+export type MoraData = {
+	subscribers: Set<() => void>;
+	values: Set<Reactive<unknown>>;
+};
+export declare function setReactiveValue(data: FragmentData, comment: Comment, reactive: Reactive<unknown>): void;
+
+export {};

package/types/node/value.d.ts

@@ -1,3 +1,3 @@
-import { type Reactive } from '@oscarpalmer/sentinel';
+import type { Reactive } from '@oscarpalmer/mora';
 import type { FragmentData } from '../models';
-export declare function setReactiveNode(data: FragmentData, comment: Comment, reactive: Reactive): void;
+export declare function setReactiveValue(data: FragmentData, comment: Comment, reactive: Reactive<unknown>): void;

package/types/parse.d.cts

@@ -0,0 +1,108 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A generic key type
+ */
+export type Key = number | string;
+export type GenericCallback = (...args: any[]) => any;
+declare class Effect {
+	private readonly $mora;
+	private readonly state;
+	constructor(callback: GenericCallback);
+}
+declare class Computed<Value> extends Reactive<Value> {
+	private readonly effect;
+	constructor(callback: () => Value, options?: ReactiveOptions<Value>);
+	/**
+	 * @inheritdoc
+	 */
+	get(): Value;
+}
+declare abstract class Reactive<Value, Equal = Value> {
+	protected readonly state: ReactiveState<Value, Equal>;
+	constructor(name: string, value: Value, options?: ReactiveOptions<Equal>);
+	/**
+	 * Get the value
+	 */
+	abstract get(): Value;
+	/**
+	 * Get the value _(without reactivity)_
+	 */
+	peek(): Value;
+	/**
+	 * Subscribe to changes
+	 */
+	subscribe(callback: (value: Value) => void): Unsubscribe;
+	/**
+	 * JSON representation of the value
+	 */
+	toJSON(): Value;
+	/**
+	 * String representation of the value
+	 */
+	toString(): string;
+	/**
+	 * Unsubscribe from changes
+	 */
+	unsubscribe(callback: (value: Value) => void): void;
+}
+export type ReactiveOptions<Value> = {
+	/**
+	 * Method to compare values for equality
+	 */
+	equal?: (first: Value, second: Value) => boolean;
+};
+export type ReactiveState<Value, Equal> = {
+	computeds: Set<Computed<unknown>>;
+	effects: Set<Effect>;
+	equal: (first: Equal, second: Equal) => boolean;
+	subscriptions: Map<GenericCallback, Subscription>;
+	value: Value;
+};
+declare class Subscription {
+	state: ReactiveState<unknown, never>;
+	callback: GenericCallback;
+	constructor(state: ReactiveState<unknown, never>, callback: GenericCallback);
+}
+/**
+ * Unsubscribe from changes
+ */
+export type Unsubscribe = () => void;
+declare class Fragment {
+	private readonly $fragment;
+	private readonly data;
+	get identifier(): Key | undefined;
+	constructor(strings: TemplateStringsArray, expressions: unknown[]);
+	/**
+	 * Appends the fragment to the given element
+	 */
+	appendTo(element: Element): void;
+	/**
+	 * Gets a list of the fragment's nodes
+	 */
+	get(): ChildNode[];
+	identify(identifier: Key): Fragment;
+	/**
+	 * Removes the fragment from the DOM
+	 */
+	remove(): void;
+}
+export type FragmentData = {
+	expressions: unknown[];
+	identifier?: Key;
+	items: FragmentItem[];
+	mora: MoraData;
+	strings: TemplateStringsArray;
+	values: unknown[];
+};
+export type FragmentItem = {
+	fragments?: Fragment[];
+	nodes: ChildNode[];
+};
+export type MoraData = {
+	subscribers: Set<() => void>;
+	values: Set<Reactive<unknown>>;
+};
+export declare function parse(data: FragmentData): string;
+
+export {};

package/types/parse.d.ts

@@ -0,0 +1,2 @@
+import type { FragmentData } from './models';
+export declare function parse(data: FragmentData): string;

package/dist/fragment.mjs

@@ -1,58 +0,0 @@
-// src/fragment.ts
-import {html as html2} from "@oscarpalmer/toretto/html";
-import {parse} from "./html";
-import {mapNodes} from "./node";
-import {removeNodes} from "./helpers/dom";
-
-class Fragment {
-  $fragment = true;
-  data;
-  get identifier() {
-    return this.data.identifier;
-  }
-  constructor(strings, expressions) {
-    this.data = {
-      expressions,
-      strings,
-      items: [],
-      values: []
-    };
-  }
-  appendTo(element) {
-    element.append(...this.get());
-  }
-  get() {
-    if (this.data.items.length === 0) {
-      const parsed = parse(this.data);
-      const templated = html2(parsed, {
-        sanitiseBooleanAttributes: false
-      });
-      this.data.items.splice(0, this.data.items.length, ...templated.map((node2) => ({
-        nodes: [node2]
-      })));
-      mapNodes(this.data, this.data.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes));
-    }
-    return [
-      ...this.data.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes)
-    ];
-  }
-  identify(identifier) {
-    this.data.identifier = identifier;
-    return this;
-  }
-  remove() {
-    const { length } = this.data.items;
-    for (let index = 0;index < length; index += 1) {
-      const { fragments, nodes } = this.data.items[index];
-      const { length: length2 } = fragments ?? [];
-      for (let index2 = 0;index2 < length2; index2 += 1) {
-        fragments?.[index2]?.remove();
-      }
-      removeNodes(nodes);
-    }
-    this.data.items.splice(0, length);
-  }
-}
-export {
-  Fragment
-};

package/dist/helpers/dom.mjs

@@ -1,44 +0,0 @@
-// src/helpers/dom.ts
-import {getString} from "@oscarpalmer/atoms/string";
-import {isFragment, isProperElement, isProperNode} from "./index";
-import {removeEvents} from "../node/event";
-function createNodes(value) {
-  if (isFragment(value)) {
-    return value.get();
-  }
-  if (isProperNode(value)) {
-    return [value];
-  }
-  return [new Text(getString(value))];
-}
-function removeNodes(nodes) {
-  sanitiseNodes(nodes);
-  const { length } = nodes;
-  for (let index = 0;index < length; index += 1) {
-    nodes[index].remove();
-  }
-}
-function replaceNodes(from, to) {
-  from[0]?.replaceWith(...to);
-  const { length } = from;
-  for (let index = 1;index < length; index += 1) {
-    from[index].remove();
-  }
-}
-function sanitiseNodes(nodes) {
-  const { length } = nodes;
-  for (let index = 0;index < length; index += 1) {
-    const node = nodes[index];
-    if (isProperElement(node)) {
-      removeEvents(node);
-    }
-    if (node.hasChildNodes()) {
-      sanitiseNodes([...node.childNodes]);
-    }
-  }
-}
-export {
-  replaceNodes,
-  removeNodes,
-  createNodes
-};

package/dist/helpers/index.mjs

@@ -1,25 +0,0 @@
-// src/helpers/index.ts
-function compareArrays(first, second) {
-  const firstIsLarger = first.length > second.length;
-  const from = firstIsLarger ? first : second;
-  const to = firstIsLarger ? second : first;
-  if (!from.filter((key) => to.includes(key)).every((key, index) => to[index] === key)) {
-    return "dissimilar";
-  }
-  return firstIsLarger ? "removed" : "added";
-}
-function isFragment(value) {
-  return typeof value === "object" && value != null && "$fragment" in value && value.$fragment === true;
-}
-function isProperElement(value) {
-  return value instanceof HTMLElement || value instanceof SVGElement;
-}
-function isProperNode(value) {
-  return value instanceof CharacterData || value instanceof Element;
-}
-export {
-  isProperNode,
-  isProperElement,
-  isFragment,
-  compareArrays
-};

package/dist/html.mjs

@@ -1,36 +0,0 @@
-// src/html.ts
-import {isNullableOrWhitespace} from "@oscarpalmer/atoms/is";
-import {Fragment} from "./fragment";
-function handleExpression(data, prefix, expression) {
-  if (isNullableOrWhitespace(expression)) {
-    return prefix;
-  }
-  if (Array.isArray(expression)) {
-    const { length } = expression;
-    let expressions = "";
-    for (let index = 0;index < length; index += 1) {
-      expressions += handleExpression(data, "", expression[index]);
-    }
-    return `${prefix}${expressions}`;
-  }
-  if (typeof expression === "function" || typeof expression === "object") {
-    const index = data.values.push(expression) - 1;
-    return `${prefix}<!--abydon.${index}-->`;
-  }
-  return `${prefix}${expression}`;
-}
-function html(strings, ...values) {
-  return new Fragment(strings, values);
-}
-function parse(data) {
-  const { length } = data.strings;
-  let template = "";
-  for (let index = 0;index < length; index += 1) {
-    template += handleExpression(data, data.strings[index], data.expressions[index]);
-  }
-  return template;
-}
-export {
-  parse,
-  html
-};

package/dist/index.mjs

@@ -1,5 +0,0 @@
-// src/index.ts
-import {html} from "./html";
-export {
-  html
-};

package/dist/node/attribute/index.mjs

@@ -1,35 +0,0 @@
-// src/node/attribute/index.ts
-import {computed, isReactive} from "@oscarpalmer/sentinel";
-import {mapEvent} from "../event";
-import {setAttribute} from "./value";
-function getValue(data, original) {
-  const matches = commentExpression.exec(original ?? "");
-  return matches == null ? original : data.values[+matches[1]];
-}
-function mapAttributes(data, element) {
-  const attributes = [...element.attributes];
-  const { length } = attributes;
-  for (let index = 0;index < length; index += 1) {
-    const { name, value: value2 } = attributes[index];
-    const actual = getValue(data, value2);
-    if (name.startsWith("@")) {
-      mapEvent(element, name, actual);
-    } else if (name.includes(".") || typeof value2 === "function" || isReactive(actual)) {
-      mapValue(element, name, actual);
-    }
-  }
-}
-function mapValue(element, name, value2) {
-  switch (true) {
-    case typeof value2 === "function":
-      setAttribute(element, name, computed(value2));
-      break;
-    default:
-      setAttribute(element, name, value2);
-      break;
-  }
-}
-var commentExpression = /^<!--abydon\.(\d+)-->$/;
-export {
-  mapAttributes
-};

package/dist/node/attribute/value.mjs

@@ -1,89 +0,0 @@
-// src/node/attribute/value.ts
-import {getString} from "@oscarpalmer/atoms/string";
-import {effect, isReactive} from "@oscarpalmer/sentinel";
-import {
-isBooleanAttribute,
-setAttribute as setAttr
-} from "@oscarpalmer/toretto/attribute";
-function setAttribute(element, name, value) {
-  element.removeAttribute(name);
-  switch (true) {
-    case classExpression.test(name):
-      setClasses(element, name, value);
-      return;
-    case stylePrefixExpression.test(name):
-      setStyle(element, name, value);
-      return;
-    default:
-      setValue(element, name, value);
-      break;
-  }
-}
-function setClasses(element, name, value) {
-  function update(value2) {
-    if (value2 === true) {
-      element.classList.add(...classes);
-    } else {
-      element.classList.remove(...classes);
-    }
-  }
-  const classes = name.slice(6).split(".");
-  if (isReactive(value)) {
-    effect(() => {
-      update(value.get());
-    });
-  } else {
-    update(value);
-  }
-}
-function setStyle(element, name, value) {
-  function update(value2) {
-    if (value2 == null || value2 === false || value2 === true && unit == null) {
-      element.style.removeProperty(property);
-    } else {
-      element.style.setProperty(property, value2 === true ? unit : getString(value2));
-    }
-  }
-  const [, property, unit] = styleFullExpression.exec(name) ?? [];
-  if (property != null) {
-    if (isReactive(value)) {
-      effect(() => {
-        update(value.get());
-      });
-    } else {
-      update(value);
-    }
-  }
-}
-function setValue(element, name, value) {
-  const callback = isBooleanAttribute(name) && name in element ? name === "selected" ? updateSelected : updateProperty : setAttr;
-  if (isReactive(value)) {
-    effect(() => {
-      callback(element, name, value.get());
-    });
-  } else {
-    callback(element, name, value);
-  }
-}
-function triggerSelectChange(select) {
-  if (select != null) {
-    select.dispatchEvent(new Event("change", { bubbles: true }));
-  }
-}
-function updateProperty(element, name, value) {
-  element[name] = value === true;
-}
-function updateSelected(element, name, value) {
-  const select = element.closest("select");
-  const options = [...select?.options ?? []];
-  if (select != null && options.includes(element)) {
-    triggerSelectChange(select);
-  }
-  updateProperty(element, name, value);
-}
-var classExpression = /^class\./;
-var styleFullExpression = /^style\.([\w-]+)(?:\.([\w-]+))?$/;
-var stylePrefixExpression = /^style\./;
-export {
-  setAttribute
-};

package/dist/node/event.mjs

@@ -1,39 +0,0 @@
-// src/node/event.ts
-function getController(element) {
-  let controller = controllers.get(element);
-  if (controller == null) {
-    controller = new AbortController;
-    controllers.set(element, controller);
-  }
-  return controller;
-}
-function getOptions(options) {
-  const parts = options.split(":");
-  return {
-    capture: parts.includes("c") || parts.includes("capture"),
-    once: parts.includes("o") || parts.includes("once"),
-    passive: !parts.includes("a") && !parts.includes("active")
-  };
-}
-function mapEvent(element, name, value) {
-  element.removeAttribute(name);
-  const [, type, options] = eventNamePattern.exec(name) ?? [];
-  if (typeof value === "function" && type != null) {
-    element.addEventListener(type, value, {
-      ...getOptions(options ?? ""),
-      signal: getController(element).signal
-    });
-  }
-}
-function removeEvents(element) {
-  if (controllers.has(element)) {
-    controllers.get(element)?.abort();
-    controllers.delete(element);
-  }
-}
-var controllers = new WeakMap;
-var eventNamePattern = /^@([\w-]+)(?::([a-z:]+))?$/i;
-export {
-  removeEvents,
-  mapEvent
-};