@oscarpalmer/abydon 0.12.0 → 0.13.0

package/types/node/attribute/value.d.cts

@@ -0,0 +1,109 @@
+// 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>>;
+};
+type HTMLOrSVGElement$1 = HTMLElement | SVGElement;
+export declare function setAttribute(data: FragmentData, element: HTMLOrSVGElement$1, name: string, value: unknown): void;
+
+export {};

package/types/node/attribute/value.d.ts

@@ -1,2 +1,3 @@
-import type { FragmentData, HTMLOrSVGElement } from '../../models';
+import type { HTMLOrSVGElement } from '@oscarpalmer/toretto/models';
+import type { FragmentData } from '../../models';
 export declare function setAttribute(data: FragmentData, element: HTMLOrSVGElement, name: string, value: unknown): void;

package/types/node/event.d.cts

@@ -0,0 +1,7 @@
+// Generated by dts-bundle-generator v9.5.1
+
+type HTMLOrSVGElement$1 = HTMLElement | SVGElement;
+export declare function mapEvent(element: HTMLOrSVGElement$1, name: string, value: unknown): void;
+export declare function removeEvents(element: HTMLOrSVGElement$1): void;
+
+export {};

package/types/node/event.d.ts

@@ -1,3 +1,3 @@
-import type { HTMLOrSVGElement } from '../models';
+import type { HTMLOrSVGElement } from '@oscarpalmer/toretto/models';
 export declare function mapEvent(element: HTMLOrSVGElement, name: string, value: unknown): void;
 export declare function removeEvents(element: HTMLOrSVGElement): void;

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/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 setReactiveValue(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,75 +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";
-function removeFragment(data) {
-  removeSentinels(data);
-  const { length } = data.items;
-  for (let index = 0;index < length; index += 1) {
-    const { fragments, nodes } = data.items[index];
-    const { length: length2 } = fragments ?? [];
-    for (let index2 = 0;index2 < length2; index2 += 1) {
-      fragments?.[index2]?.remove();
-    }
-    removeNodes(nodes);
-  }
-  data.items.splice(0, length);
-}
-function removeSentinels(data) {
-  const sentinels = [...data.sentinel.effects, ...data.sentinel.values];
-  const { length } = sentinels;
-  for (let index = 0;index < length; index += 1) {
-    sentinels[index].stop();
-  }
-  data.sentinel.effects.clear();
-  data.sentinel.values.clear();
-}
-
-class Fragment {
-  $fragment = true;
-  data;
-  get identifier() {
-    return this.data.identifier;
-  }
-  constructor(strings, expressions) {
-    this.data = {
-      expressions,
-      strings,
-      items: [],
-      sentinel: {
-        effects: new Set,
-        values: new Set
-      },
-      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() {
-    removeFragment(this.data);
-  }
-}
-export {
-  Fragment
-};

package/dist/helpers/dom.mjs

@@ -1,44 +0,0 @@
-// src/helpers/dom.ts
-import {getString} from "@oscarpalmer/atoms/string";
-import {isChildNode, isFragment, isHTMLOrSVGElement} from "./index";
-import {removeEvents} from "../node/event";
-function createNodes(value) {
-  if (isFragment(value)) {
-    return value.get();
-  }
-  if (isChildNode(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 (isHTMLOrSVGElement(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 isChildNode(value) {
-  return value instanceof CharacterData || value instanceof Element;
-}
-function isFragment(value) {
-  return typeof value === "object" && value != null && "$fragment" in value && value.$fragment === true;
-}
-function isHTMLOrSVGElement(value) {
-  return value instanceof HTMLElement || value instanceof SVGElement;
-}
-export {
-  isHTMLOrSVGElement,
-  isFragment,
-  isChildNode,
-  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,6 +0,0 @@
-// src/index.ts
-import"@oscarpalmer/sentinel";
-import {html} from "./html";
-export {
-  html
-};

package/dist/node/attribute/index.mjs

@@ -1,40 +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(data, element, name, actual);
-    }
-  }
-}
-function mapValue(data, element, name, value2) {
-  switch (true) {
-    case typeof value2 === "function":
-      setComputedAttribute(data, element, name, value2);
-      break;
-    default:
-      setAttribute(data, element, name, value2);
-      break;
-  }
-}
-function setComputedAttribute(data, element, name, callback) {
-  const value2 = computed(callback);
-  data.sentinel.values.add(value2);
-  setAttribute(data, element, name, value2);
-}
-var commentExpression = /^<!--abydon\.(\d+)-->$/;
-export {
-  mapAttributes
-};