@manyducks.co/dolla 2.0.0-alpha.54 → 2.0.0-alpha.55

package/dist/{typeChecking-EAVNeFyB.js.map → typeChecking-lgllKIVq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"typeChecking-EAVNeFyB.js","sources":["../src/typeChecking.ts"],"sourcesContent":["type TypeNames =\n  // These values can be returned by `typeof`.\n  | \"string\"\n  | \"number\"\n  | \"bigint\"\n  | \"boolean\"\n  | \"symbol\"\n  | \"undefined\"\n  | \"object\"\n  | \"function\"\n  // These values are more specific ones that the `typeOf` function can return.\n  | \"null\"\n  | \"array\"\n  | \"class\"\n  | \"promise\"\n  | \"map\"\n  | \"set\"\n  | \"NaN\";\n\n/**\n * Extends `typeof` operator with more specific and useful type distinctions.\n */\nexport function typeOf(value: any): TypeNames {\n  const type = typeof value;\n  switch (type) {\n    case \"undefined\":\n      return type;\n    case \"number\":\n      if (isNaN(value as any)) return \"NaN\";\n      return type;\n    case \"function\":\n      if (/^\\s*class\\s+/.test(value.toString())) return \"class\";\n      return type;\n    case \"object\":\n      if (value === null) return \"null\";\n      if (value instanceof Promise) return \"promise\";\n      if (value instanceof Map) return \"map\";\n      if (value instanceof Set) return \"set\";\n      if (Array.isArray(value)) return \"array\";\n      return type;\n    default:\n      return type;\n  }\n}\n\n/**\n * Throws a TypeError unless `condition` is truthy.\n *\n * @param condition - Value whose truthiness is in question.\n * @param errorMessage - Optional message for the thrown TypeError.\n */\nexport function assert(condition: any, errorMessage?: string): void {\n  if (!condition) {\n    throw new TypeError(\n      formatError(condition, errorMessage || \"Failed assertion. Value is not truthy. Got type: %t, value: %v\"),\n    );\n  }\n}\n\n/**\n * Returns true if `value` is an array.\n */\nexport function isArray(value: unknown): value is Array<unknown> {\n  return Array.isArray(value);\n}\n\n/**\n * Throws an error if `value` is not an array.\n */\nexport function assertArray(value: unknown, errorMessage?: string): value is Array<unknown> {\n  if (isArray(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage || \"Expected array. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true when `value` is an array and `check` returns true for every item.\n *\n * @param check - Function to check items against.\n * @param value - A possible array.\n */\n\nexport function isArrayOf<T>(check: (item: unknown) => boolean, value: unknown): value is T[] {\n  return isArray(value) && value.every((item) => check(item));\n}\n\n/**\n * Throws a TypeError unless `value` is an array and `check` returns true for every item.\n *\n * @param check - Function to check items against.\n * @param value - A possible array.\n * @param errorMessage - A custom error message.\n */\nexport function assertArrayOf<T>(\n  check: (item: unknown) => boolean,\n  value: unknown,\n  errorMessage?: string,\n): value is T[] {\n  if (isArrayOf(check, value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected an array of valid items. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true if `value` is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === \"string\";\n}\n\n/**\n * Throws a TypeError unless `value` is a string.\n */\nexport function assertString(value: unknown, errorMessage?: string): value is string {\n  if (isString(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a string. Got type: %t, value: %v\"));\n}\n\n// TODO: More specific validation for common types of strings? Email address, URL, UUID, etc?\n\n/**\n * Returns true if `value` is a function (but not a class).\n */\nexport function isFunction<T = (...args: unknown[]) => unknown>(value: unknown): value is T {\n  return typeOf(value) === \"function\";\n}\n\n/**\n * Throws a TypeError unless `value` is a function.\n */\nexport function assertFunction<T = (...args: unknown[]) => unknown>(value: unknown, errorMessage?: string): value is T {\n  if (isFunction(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a function. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true if `value` is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === \"number\" && !isNaN(value);\n}\n\n/**\n * Throws a TypeError unless `value` is a number.\n */\nexport function assertNumber(value: unknown, errorMessage?: string): value is number {\n  if (isNumber(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a number. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns a function that takes a `value` and returns true if `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor a value must be an instance of to match.\n */\nexport function isInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;\n\n/**\n * Returns `true` if `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor `value` must be an instance of.\n * @param value - A value that may be an instance of `constructor`.\n */\nexport function isInstanceOf<T extends Function>(constructor: T, value: unknown): value is T;\n\nexport function isInstanceOf<T extends Function>(...args: unknown[]) {\n  const constructor = args[0] as T;\n\n  const test = (value: unknown): value is T => {\n    return value instanceof constructor;\n  };\n\n  if (args.length < 2) {\n    return test;\n  } else {\n    return test(args[1]);\n  }\n}\n\n/**\n * Returns a function that takes a `value` and throws a TypeError unless `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor a value must be an instance of to match.\n */\nexport function assertInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;\n\n/**\n * Throws a TypeError unless `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor `value` must be an instance of.\n * @param value - A value that may be an instance of `constructor`.\n * @param errorMessage - A custom error message for when the assertion fails.\n */\nexport function assertInstanceOf<T extends Function>(constructor: T, value: unknown, errorMessage?: string): value is T;\n\nexport function assertInstanceOf<T extends Function>(...args: unknown[]) {\n  const constructor = args[0] as T;\n  const errorMessage = isString(args[2])\n    ? args[2]\n    : `Expected instance of ${constructor.name}. Got type: %t, value: %v`;\n\n  const test = (value: unknown): value is T => {\n    if (value instanceof constructor) {\n      return true;\n    }\n\n    throw new TypeError(formatError(value, errorMessage));\n  };\n\n  if (args.length < 2) {\n    return test;\n  } else {\n    return test(args[1]);\n  }\n}\n\n/**\n * Returns true if `value` is a plain JavaScript object.\n */\nexport function isObject(value: unknown): value is Record<string | number | symbol, unknown> {\n  return value != null && typeof value === \"object\" && !isArray(value);\n}\n\n/**\n * Throws a TypeError unless `value` is a plain JavaScript object.\n */\nexport function assertObject(value: unknown, errorMessage?: string): value is object {\n  if (isObject(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected an object. Got type: %t, value: %v\"));\n}\n\n/**\n * Replaces `%t` and `%v` placeholders in a message with real values.\n */\nfunction formatError(value: unknown, message: string) {\n  const typeName = typeOf(value);\n\n  // TODO: Pretty format value as string based on type.\n  const valueString = value?.toString?.() || String(value);\n\n  return message.replaceAll(\"%t\", typeName).replaceAll(\"%v\", valueString);\n}\n"],"names":["typeOf","value","type","isArray","isArrayOf","check","item","assertArrayOf","errorMessage","formatError","isString","assertString","isFunction","isNumber","assertInstanceOf","args","constructor","test","isObject","assertObject","message","_a","typeName","valueString"],"mappings":"AAsBO,SAASA,EAAOC,GAAuB;AAC5C,QAAMC,IAAO,OAAOD;AACpB,UAAQC,GAAM;AAAA,IACZ,KAAK;AACI,aAAAA;AAAA,IACT,KAAK;AACC,aAAA,MAAMD,CAAY,IAAU,QACzBC;AAAA,IACT,KAAK;AACH,aAAI,eAAe,KAAKD,EAAM,SAAU,CAAA,IAAU,UAC3CC;AAAA,IACT,KAAK;AACC,aAAAD,MAAU,OAAa,SACvBA,aAAiB,UAAgB,YACjCA,aAAiB,MAAY,QAC7BA,aAAiB,MAAY,QAC7B,MAAM,QAAQA,CAAK,IAAU,UAC1BC;AAAA,IACT;AACS,aAAAA;AAAA,EAAA;AAEb;AAmBO,SAASC,EAAQF,GAAyC;AACxD,SAAA,MAAM,QAAQA,CAAK;AAC5B;AAoBgB,SAAAG,EAAaC,GAAmCJ,GAA8B;AACrF,SAAAE,EAAQF,CAAK,KAAKA,EAAM,MAAM,CAACK,MAASD,EAAMC,CAAI,CAAC;AAC5D;AASgB,SAAAC,EACdF,GACAJ,GACAO,GACc;AACV,MAAAJ,EAAUC,GAAOJ,CAAK;AACjB,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,CAA2E,CAAC;AACrH;AAKO,SAASE,EAAST,GAAiC;AACxD,SAAO,OAAOA,KAAU;AAC1B;AAKgB,SAAAU,EAAaV,GAAgBO,GAAwC;AAC/E,MAAAE,EAAST,CAAK;AACT,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,KAAgB,4CAA4C,CAAC;AACtG;AAOO,SAASI,EAAgDX,GAA4B;AACnF,SAAAD,EAAOC,CAAK,MAAM;AAC3B;AAgBO,SAASY,EAASZ,GAAiC;AACxD,SAAO,OAAOA,KAAU,YAAY,CAAC,MAAMA,CAAK;AAClD;AA0DO,SAASa,KAAwCC,GAAiB;AACjE,QAAAC,IAAcD,EAAK,CAAC,GACpBP,IAAeE,EAASK,EAAK,CAAC,CAAC,IACjCA,EAAK,CAAC,IACN,wBAAwBC,EAAY,IAAI,6BAEtCC,IAAO,CAAChB,MAA+B;AAC3C,QAAIA,aAAiBe;AACZ,aAAA;AAGT,UAAM,IAAI,UAAUP,EAAYR,GAAOO,CAAY,CAAC;AAAA,EACtD;AAEI,SAAAO,EAAK,SAAS,IACTE,IAEAA,EAAKF,EAAK,CAAC,CAAC;AAEvB;AAKO,SAASG,EAASjB,GAAoE;AAC3F,SAAOA,KAAS,QAAQ,OAAOA,KAAU,YAAY,CAACE,EAAQF,CAAK;AACrE;AAKgB,SAAAkB,EAAalB,GAAgBO,GAAwC;AAC/E,MAAAU,EAASjB,CAAK;AACT,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,CAA6D,CAAC;AACvG;AAKA,SAASC,EAAYR,GAAgBmB,GAAiB;AApO/C,MAAAC;AAqOC,QAAAC,IAAWtB,EAAOC,CAAK,GAGvBsB,MAAcF,IAAApB,KAAA,gBAAAA,EAAO,aAAP,gBAAAoB,EAAA,KAAApB,OAAuB,OAAOA,CAAK;AAEvD,SAAOmB,EAAQ,WAAW,MAAME,CAAQ,EAAE,WAAW,MAAMC,CAAW;AACxE;"}
+{"version":3,"file":"typeChecking-lgllKIVq.js","sources":["../src/typeChecking.ts"],"sourcesContent":["type TypeNames =\n  // These values can be returned by `typeof`.\n  | \"string\"\n  | \"number\"\n  | \"bigint\"\n  | \"boolean\"\n  | \"symbol\"\n  | \"undefined\"\n  | \"object\"\n  | \"function\"\n  // These values are more specific ones that the `typeOf` function can return.\n  | \"null\"\n  | \"array\"\n  | \"class\"\n  | \"promise\"\n  | \"map\"\n  | \"set\"\n  | \"NaN\";\n\n/**\n * Extends `typeof` operator with more specific and useful type distinctions.\n */\nexport function typeOf(value: any): TypeNames {\n  const type = typeof value;\n  switch (type) {\n    case \"undefined\":\n      return type;\n    case \"number\":\n      if (isNaN(value as any)) return \"NaN\";\n      return type;\n    case \"function\":\n      if (/^\\s*class\\s+/.test(value.toString())) return \"class\";\n      return type;\n    case \"object\":\n      if (value === null) return \"null\";\n      if (value instanceof Promise) return \"promise\";\n      if (value instanceof Map) return \"map\";\n      if (value instanceof Set) return \"set\";\n      if (Array.isArray(value)) return \"array\";\n      return type;\n    default:\n      return type;\n  }\n}\n\n/**\n * Throws a TypeError unless `condition` is truthy.\n *\n * @param condition - Value whose truthiness is in question.\n * @param errorMessage - Optional message for the thrown TypeError.\n */\nexport function assert(condition: any, errorMessage?: string): void {\n  if (!condition) {\n    throw new TypeError(\n      formatError(condition, errorMessage || \"Failed assertion. Value is not truthy. Got type: %t, value: %v\"),\n    );\n  }\n}\n\n/**\n * Returns true if `value` is an array.\n */\nexport function isArray(value: unknown): value is Array<unknown> {\n  return Array.isArray(value);\n}\n\n/**\n * Throws an error if `value` is not an array.\n */\nexport function assertArray(value: unknown, errorMessage?: string): value is Array<unknown> {\n  if (isArray(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage || \"Expected array. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true when `value` is an array and `check` returns true for every item.\n *\n * @param check - Function to check items against.\n * @param value - A possible array.\n */\n\nexport function isArrayOf<T>(check: (item: unknown) => boolean, value: unknown): value is T[] {\n  return isArray(value) && value.every((item) => check(item));\n}\n\n/**\n * Throws a TypeError unless `value` is an array and `check` returns true for every item.\n *\n * @param check - Function to check items against.\n * @param value - A possible array.\n * @param errorMessage - A custom error message.\n */\nexport function assertArrayOf<T>(\n  check: (item: unknown) => boolean,\n  value: unknown,\n  errorMessage?: string,\n): value is T[] {\n  if (isArrayOf(check, value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected an array of valid items. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true if `value` is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === \"string\";\n}\n\n/**\n * Throws a TypeError unless `value` is a string.\n */\nexport function assertString(value: unknown, errorMessage?: string): value is string {\n  if (isString(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a string. Got type: %t, value: %v\"));\n}\n\n// TODO: More specific validation for common types of strings? Email address, URL, UUID, etc?\n\n/**\n * Returns true if `value` is a function (but not a class).\n */\nexport function isFunction<T = (...args: unknown[]) => unknown>(value: unknown): value is T {\n  return typeOf(value) === \"function\";\n}\n\n/**\n * Throws a TypeError unless `value` is a function.\n */\nexport function assertFunction<T = (...args: unknown[]) => unknown>(value: unknown, errorMessage?: string): value is T {\n  if (isFunction(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a function. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns true if `value` is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === \"number\" && !isNaN(value);\n}\n\n/**\n * Throws a TypeError unless `value` is a number.\n */\nexport function assertNumber(value: unknown, errorMessage?: string): value is number {\n  if (isNumber(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected a number. Got type: %t, value: %v\"));\n}\n\n/**\n * Returns a function that takes a `value` and returns true if `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor a value must be an instance of to match.\n */\nexport function isInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;\n\n/**\n * Returns `true` if `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor `value` must be an instance of.\n * @param value - A value that may be an instance of `constructor`.\n */\nexport function isInstanceOf<T extends Function>(constructor: T, value: unknown): value is T;\n\nexport function isInstanceOf<T extends Function>(...args: unknown[]) {\n  const constructor = args[0] as T;\n\n  const test = (value: unknown): value is T => {\n    return value instanceof constructor;\n  };\n\n  if (args.length < 2) {\n    return test;\n  } else {\n    return test(args[1]);\n  }\n}\n\n/**\n * Returns a function that takes a `value` and throws a TypeError unless `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor a value must be an instance of to match.\n */\nexport function assertInstanceOf<T extends Function>(constructor: T): (value: unknown) => value is T;\n\n/**\n * Throws a TypeError unless `value` is an instance of `constructor`.\n *\n * @param constructor - The constructor `value` must be an instance of.\n * @param value - A value that may be an instance of `constructor`.\n * @param errorMessage - A custom error message for when the assertion fails.\n */\nexport function assertInstanceOf<T extends Function>(constructor: T, value: unknown, errorMessage?: string): value is T;\n\nexport function assertInstanceOf<T extends Function>(...args: unknown[]) {\n  const constructor = args[0] as T;\n  const errorMessage = isString(args[2])\n    ? args[2]\n    : `Expected instance of ${constructor.name}. Got type: %t, value: %v`;\n\n  const test = (value: unknown): value is T => {\n    if (value instanceof constructor) {\n      return true;\n    }\n\n    throw new TypeError(formatError(value, errorMessage));\n  };\n\n  if (args.length < 2) {\n    return test;\n  } else {\n    return test(args[1]);\n  }\n}\n\n/**\n * Returns true if `value` is a plain JavaScript object.\n */\nexport function isObject(value: unknown): value is Record<string | number | symbol, unknown> {\n  return value != null && typeof value === \"object\" && !isArray(value);\n}\n\n/**\n * Throws a TypeError unless `value` is a plain JavaScript object.\n */\nexport function assertObject(value: unknown, errorMessage?: string): value is object {\n  if (isObject(value)) {\n    return true;\n  }\n\n  throw new TypeError(formatError(value, errorMessage ?? \"Expected an object. Got type: %t, value: %v\"));\n}\n\n/**\n * Replaces `%t` and `%v` placeholders in a message with real values.\n */\nfunction formatError(value: unknown, message: string) {\n  const typeName = typeOf(value);\n\n  // TODO: Pretty format value as string based on type.\n  const valueString = value?.toString?.() || String(value);\n\n  return message.replaceAll(\"%t\", typeName).replaceAll(\"%v\", valueString);\n}\n"],"names":["typeOf","value","type","isArray","isArrayOf","check","item","assertArrayOf","errorMessage","formatError","isString","assertString","isFunction","isNumber","assertInstanceOf","args","constructor","test","isObject","assertObject","message","_a","typeName","valueString"],"mappings":"AAsBO,SAASA,EAAOC,GAAuB;AAC5C,QAAMC,IAAO,OAAOD;AACpB,UAAQC,GAAM;AAAA,IACZ,KAAK;AACI,aAAAA;AAAA,IACT,KAAK;AACC,aAAA,MAAMD,CAAY,IAAU,QACzBC;AAAA,IACT,KAAK;AACH,aAAI,eAAe,KAAKD,EAAM,SAAU,CAAA,IAAU,UAC3CC;AAAA,IACT,KAAK;AACC,aAAAD,MAAU,OAAa,SACvBA,aAAiB,UAAgB,YACjCA,aAAiB,MAAY,QAC7BA,aAAiB,MAAY,QAC7B,MAAM,QAAQA,CAAK,IAAU,UAC1BC;AAAA,IACT;AACS,aAAAA;AAAA,EAAA;AAEb;AAmBO,SAASC,EAAQF,GAAyC;AACxD,SAAA,MAAM,QAAQA,CAAK;AAC5B;AAoBgB,SAAAG,EAAaC,GAAmCJ,GAA8B;AACrF,SAAAE,EAAQF,CAAK,KAAKA,EAAM,MAAM,CAACK,MAASD,EAAMC,CAAI,CAAC;AAC5D;AASgB,SAAAC,EACdF,GACAJ,GACAO,GACc;AACV,MAAAJ,EAAUC,GAAOJ,CAAK;AACjB,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,CAA2E,CAAC;AACrH;AAKO,SAASE,EAAST,GAAiC;AACxD,SAAO,OAAOA,KAAU;AAC1B;AAKgB,SAAAU,EAAaV,GAAgBO,GAAwC;AAC/E,MAAAE,EAAST,CAAK;AACT,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,KAAgB,4CAA4C,CAAC;AACtG;AAOO,SAASI,EAAgDX,GAA4B;AACnF,SAAAD,EAAOC,CAAK,MAAM;AAC3B;AAgBO,SAASY,EAASZ,GAAiC;AACxD,SAAO,OAAOA,KAAU,YAAY,CAAC,MAAMA,CAAK;AAClD;AA0DO,SAASa,KAAwCC,GAAiB;AACjE,QAAAC,IAAcD,EAAK,CAAC,GACpBP,IAAeE,EAASK,EAAK,CAAC,CAAC,IACjCA,EAAK,CAAC,IACN,wBAAwBC,EAAY,IAAI,6BAEtCC,IAAO,CAAChB,MAA+B;AAC3C,QAAIA,aAAiBe;AACZ,aAAA;AAGT,UAAM,IAAI,UAAUP,EAAYR,GAAOO,CAAY,CAAC;AAAA,EACtD;AAEI,SAAAO,EAAK,SAAS,IACTE,IAEAA,EAAKF,EAAK,CAAC,CAAC;AAEvB;AAKO,SAASG,EAASjB,GAAoE;AAC3F,SAAOA,KAAS,QAAQ,OAAOA,KAAU,YAAY,CAACE,EAAQF,CAAK;AACrE;AAKgB,SAAAkB,EAAalB,GAAgBO,GAAwC;AAC/E,MAAAU,EAASjB,CAAK;AACT,WAAA;AAGT,QAAM,IAAI,UAAUQ,EAAYR,GAAOO,CAA6D,CAAC;AACvG;AAKA,SAASC,EAAYR,GAAgBmB,GAAiB;AApO/C,MAAAC;AAqOC,QAAAC,IAAWtB,EAAOC,CAAK,GAGvBsB,MAAcF,IAAApB,KAAA,gBAAAA,EAAO,aAAP,gBAAAoB,EAAA,KAAApB,OAAuB,OAAOA,CAAK;AAEvD,SAAOmB,EAAQ,WAAW,MAAME,CAAQ,EAAE,WAAW,MAAMC,CAAW;AACxE;"}

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import type * as CSS from "csstype";
 import type { Markup } from "./core/markup.js";
 import { Signal } from "./core/signals.js";
-import { Mixin } from "./core/mixin.js";
+import { Mixin } from "./core/nodes/html.js";
 /**
  * Represents everything that can be handled as a DOM node.
  * These are all the items considered valid to pass as children to any element.

package/docs/mixins.md

@@ -20,7 +20,7 @@ const logMe: Mixin = (element, ctx) => {
 <h1 mixin={logMe}>Title</h1>;
 
 // Or an array of mixins
-<p mixin={[logMe /*, more mixins */]}>Text goes here...</p>;
+<p mixin={[logMe, anotherMixin, yetAnotherMixin]}>Text goes here...</p>;
 ```
 
 ---

package/docs/ref.md

@@ -0,0 +1,93 @@
+# Ref
+
+Refs are functions that serve as a getter and setter for a stored value. Calling a ref with no arguments will return its stored value, or throw an error if no value has yet been stored. Calling a ref with a single argument will store a new value.
+
+This signature is very similar to that of a `Source` signal, with the differences being their error throwing behavior while empty and that refs are _not_ trackable in a signal context.
+
+## Pattern #1: Referencing DOM nodes
+
+The main pattern for refs is as a DOM node reference. Markup elements take a `ref` attribute to which they will pass their DOM node when they are mounted.
+
+Once you have this reference you can manipulate the node outside the usual declarative template workflow.
+
+```tsx
+import { ref } from "@manyducks.co/dolla";
+
+function ExampleView() {
+  const element = ref<HTMLElement>();
+
+  ctx.onMount(() => {
+    element().innerText = "GOODBYE THERE";
+  });
+
+  return <div ref={element}>HELLO THERE</div>;
+}
+```
+
+## Pattern #2: Controlling a child view from a parent view
+
+Another useful pattern is to pass an API object from a child view to the parent, allowing the parent to call methods to control the child view in an imperative way.
+
+```tsx
+import { ref } from "@manyducks.co/dolla";
+
+// First we'll define the view to be controlled.
+
+interface CounterViewControls {
+  increment(): void;
+  decrement(): void;
+  reset(): void;
+}
+
+interface CounterViewProps {
+  controls: Ref<CounterViewControls>;
+}
+
+function CounterView({ controls }: CounterViewProps) {
+  const $count = $(count);
+
+  // Passing a `controls` object to the ref whose methods reference internal state.
+  controls({
+    increment() {
+      $count((current) => current + 1);
+    },
+    decrement() {
+      $count((current) => current - 1);
+    },
+    reset() {
+      $count(0);
+    },
+  });
+
+  return <span>Count: {$count}</span>;
+}
+
+// Then we'll use it in the parent:
+
+function ParentView() {
+  // Create a Ref to store the controls object.
+  const controls = ref<CounterViewControls>();
+
+  return (
+    <section>
+      <h1>Counter</h1>
+
+      {/* CounterView will set the controls object */}
+      <CounterView controls={controls} />
+
+      {/* Our buttons will call the methods on the controls object causing state changes within CounterView */}
+      <button onClick={() => controls.increment()}>+1</button>
+      <button onClick={() => controls.decrement()}>-1</button>
+      <button onClick={() => controls.reset()}>=0</button>
+    </section>
+  );
+}
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/notes/scratch.md

@@ -1,5 +1,29 @@
 # Scratch Note
 
+Library needs to be easier to render standalone elements. Idea to replace constructView and a lot of the store management weirdness with a `createContext` function and a `render` function that takes markup and a context.
+
+The context is basically a refactor of the old ElementContext and serves the same purpose.
+
+```jsx
+import { m, render, createContext } from "@manyducks.co/dolla";
+
+const context = createContext();
+context.addStore(SomeStore);
+
+function ExampleView(props, ctx) {
+  // Views now access the Context directly.
+  const store = ctx.getStore(SomeStore);
+
+  return <h1>Hello World</h1>;
+}
+
+const element = render(ExampleView, context);
+
+element.mount(document.body);
+```
+
+---
+
 Idea: Monomorphic app context. Replaces StoreContext, ViewContext, etc.
 
 Routes are baked into the app once again, but

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@manyducks.co/dolla",
-  "version": "2.0.0-alpha.54",
+  "version": "2.0.0-alpha.55",
   "description": "Front-end components, routing and state management.",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/core/index.d.ts",
   "type": "module",
   "sideEffects": false,
   "repository": {

package/dist/core/mixin.d.ts

@@ -1,62 +0,0 @@
-import type { StoreConsumerContext } from "./context";
-import { type Logger } from "./logger";
-import type { HTML } from "./nodes/html";
-import { type EffectFn, type UnsubscribeFn } from "./signals";
-import { StoreFunction } from "./store";
-export interface MixinContext extends Logger, StoreConsumerContext {
-    /**
-     * An ID unique to this element.
-     */
-    readonly uid: string;
-    /**
-     * True while this element is connected to the DOM.
-     */
-    readonly isMounted: boolean;
-    /**
-     * Registers a callback to run just before this element is mounted. DOM nodes are not yet attached to the page.
-     */
-    beforeMount(callback: () => void): void;
-    /**
-     * Registers a callback to run just after this element is mounted.
-     */
-    onMount(callback: () => void): void;
-    /**
-     * Registers a callback to run just before this element is unmounted. DOM nodes are still attached to the page.
-     */
-    beforeUnmount(callback: () => void): void;
-    /**
-     * Registers a callback to run just after this element is unmounted.
-     */
-    onUnmount(callback: () => void): void;
-    /**
-     * Passes a getter function to `callback` that will track reactive states and return their current values.
-     * Callback will be run each time a tracked state gets a new value.
-     */
-    effect(callback: EffectFn): UnsubscribeFn;
-}
-export type Mixin<E extends Element = Element> = (element: E, context: MixinContext) => void;
-interface Context extends Logger {
-}
-declare class Context implements MixinContext {
-    private html;
-    private controller;
-    constructor(html: HTML, controller: MixinController);
-    readonly uid: string;
-    get isMounted(): boolean;
-    get<Value>(store: StoreFunction<any, Value>): Value;
-    beforeMount(callback: () => void): void;
-    onMount(callback: () => void): void;
-    beforeUnmount(callback: () => void): void;
-    onUnmount(callback: () => void): void;
-    effect(callback: EffectFn): UnsubscribeFn;
-}
-export declare class MixinController {
-    context: Context;
-    lifecycleListeners: Record<string, (() => void)[]>;
-    constructor(html: HTML, mixins: Mixin[]);
-    beforeMount(): void;
-    onMount(): void;
-    beforeUnmount(): void;
-    onUnmount(): void;
-}
-export {};

package/dist/core/store.d.ts

@@ -1,57 +0,0 @@
-import { type ComponentContext, type ElementContext, type StoreConsumerContext, type StoreProviderContext } from "./context.js";
-import { type Logger } from "./logger.js";
-import { type EffectFn, type UnsubscribeFn } from "./signals.js";
-export type StoreFunction<Options, Value> = (this: StoreContext, options: Options, context: StoreContext) => Value;
-export type StoreFactory<Options, Value> = Options extends undefined ? () => Store<Options, Value> : (options: Options) => Store<Options, Value>;
-export interface StoreContext extends Omit<Logger, "setName">, ComponentContext, StoreConsumerContext {
-    /**
-     * True while this store is attached to a context that is currently mounted in the view tree.
-     */
-    readonly isMounted: boolean;
-    /**
-     * Registers a callback to run just after this store is mounted.
-     */
-    onMount(callback: () => void): void;
-    /**
-     * Registers a callback to run just after this store is unmounted.
-     */
-    onUnmount(callback: () => void): void;
-    /**
-     * Passes a getter function to `callback` that will track reactive states and return their current values.
-     * Callback will be run each time a tracked state gets a new value.
-     */
-    effect(callback: EffectFn): UnsubscribeFn;
-}
-export declare class Store<Options, Value> {
-    readonly fn: StoreFunction<Options, Value>;
-    private _options;
-    /**
-     * Value is guaranteed to be set after `attach` is called.
-     */
-    value: Value;
-    isMounted: boolean;
-    elementContext: ElementContext;
-    lifecycleListeners: {
-        mount: (() => any)[];
-        unmount: (() => any)[];
-    };
-    logger: Logger;
-    id: string;
-    name: import("./signals.js").Source<string>;
-    constructor(fn: StoreFunction<Options, Value>, options: Options);
-    /**
-     * Attaches this Store to the elementContext.
-     * Returns false if there was already an instance attached, and true otherwise.
-     */
-    attach(elementContext: ElementContext): boolean;
-    handleMount(): void;
-    handleUnmount(): void;
-}
-export declare function isStore<Options, Value>(value: any): value is Store<Options, Value>;
-export declare class StoreError extends Error {
-}
-export type Stores = StoreProviderContext & StoreConsumerContext;
-/**
- * Global store registry.
- */
-export declare const Stores: Stores;

package/dist/core/views/passthrough.d.ts

@@ -1,5 +0,0 @@
-import { type ViewContext } from "../nodes/view.js";
-/**
- * A utility view that simply displays a route.
- */
-export declare function Passthrough(_: {}, ctx: ViewContext): import("../markup.js").Markup;

package/dist/fragment-CmWsN-4Y.js

@@ -1,8 +0,0 @@
-import { m } from "./view-BKpHFpWG.js";
-function a(r, n) {
-  return m("$dynamic", { source: () => r.children });
-}
-export {
-  a as F
-};
-//# sourceMappingURL=fragment-CmWsN-4Y.js.map

package/dist/fragment-CmWsN-4Y.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fragment-CmWsN-4Y.js","sources":["../src/core/views/fragment.ts"],"sourcesContent":["import type { Renderable } from \"../../types.js\";\nimport { markup } from \"../markup.js\";\nimport { type ViewContext } from \"../nodes/view.js\";\n\n/**\n * A utility view that displays its children.\n */\nexport function Fragment(props: { children?: Renderable }, ctx: ViewContext) {\n  return markup(\"$dynamic\", { source: () => props.children });\n}\n"],"names":["Fragment","props","ctx","markup"],"mappings":";AAOgB,SAAAA,EAASC,GAAkCC,GAAkB;AAC3E,SAAOC,EAAO,YAAY,EAAE,QAAQ,MAAMF,EAAM,UAAU;AAC5D;"}