solid-ctrl-flow 2.2.3 → 2.2.5

package/dist/index.d.ts

@@ -9,7 +9,7 @@ import { splitProps } from 'solid-js';
 /** Like a {@link Match} but gets the value from the closest {@link On} ancestor */
 export declare function Case(props: ParentProps<{
     value: unknown;
-}>): JSX;
+}>): JSX.Element;
 
 /**
  * Eventually wraps its content into a template if a certain condition is met.
@@ -55,13 +55,13 @@ export declare class Extractor {
     constructor(name?: string);
     readonly ctx: Context<State | undefined>;
     Joint: (props: {
-        children?: JSX;
-    }) => JSX;
-    Fallback: () => JSX;
+        children?: JSX.Element;
+    }) => JSX.Element;
+    Fallback: () => JSX.Element;
     Dest: (props: {
         hidden?: boolean | undefined;
-    }) => JSX;
-    Source: (props: Info) => JSX;
+    }) => JSX.Element;
+    Source: (props: Info) => JSX.Element;
     /**
      * Returns the number of destinations available for the current {@link Extractor}.
      * It's a getter that returns a function that will be bound to the {@link Owner} in which the getter was called.
@@ -84,7 +84,8 @@ declare type Keyed<T> = Standard<T> & {
 /**
  * Memoizes some of the properties of {@link obj}.
  * If {@link keys} is not provided, memoizes everything that get returned by {@link Reflect.ownKeys} when provided with {@link obj}.
- * The {@link equals} parameter defaults to `false` to allow the specific reactive value to have control over when its dependant effects are triggered
+ * The {@link equals} parameter defaults to `false` to allow the specific reactive value to have control over when its dependant effects are triggered.
+ * The memoized properties have {@link NO_OP} as setter, this is needed because {@link Ref}s are assigned if they're not functions, so an `undefined` forwarded {@link Ref} would throw in that case (In strict contexts)
  * @param obj Object to partially memoize
  * @param keys The keys of the properties to memoize
  * @param equals The comparator function to use on the newly created memos
@@ -120,7 +121,7 @@ export declare function memoProps<T, K extends readonly (keyof T)[]>(obj: T, key
 export declare function On<T>(props: ParentProps<{
     value: T;
     onCompare?(a: unknown, b: T): boolean;
-}>): JSX;
+}>): JSX.Element;
 
 /**
  * Ordered linked list that allows for:
@@ -133,7 +134,8 @@ export declare class OrderedLinkedList<T> {
     /** Yields all the elements PAST the current */
     [Symbol.iterator](): Generator<T>;
     /**
-     * Adds a node to the list in order
+     * Adds a node to the list in order.
+     * If two nodes have the same order, it would have been more efficient to put the latest one first, but this would not have been ok, since we also want to order by insertion time
      * @param node The node to add
      * @param comp The comparison function to use
      * @returns The same value as {@link node}

package/dist/index.mjs

@@ -1,8 +1,10 @@
 import { createMemo, splitProps, untrack, createRoot, getOwner, createComponent, Show, createContext, useContext, createRenderEffect, on, onCleanup, For, createSignal, createSelector, equalFn, Match } from "solid-js";
+const NO_OP = () => {
+};
 function memoProps(obj, keys = Reflect.ownKeys(obj), equals = false) {
   const out = {};
   for (const elm of keys)
-    Object.defineProperty(out, elm, { enumerable: true, get: createMemo(() => obj[elm], void 0, { equals }) });
+    Object.defineProperty(out, elm, { enumerable: true, set: NO_OP, get: createMemo(() => obj[elm], void 0, { equals }) });
   return out;
 }
 const splitAndMemoProps = (obj, ...keys) => {
@@ -59,14 +61,15 @@ class OrderedLinkedList {
     yield* next;
   }
   /**
-   * Adds a node to the list in order
-   * @param node The node to add
-   * @param comp The comparison function to use
-   * @returns The same value as {@link node}
-   */
+     * Adds a node to the list in order.
+  * If two nodes have the same order, it would have been more efficient to put the latest one first, but this would not have been ok, since we also want to order by insertion time
+     * @param node The node to add
+     * @param comp The comparison function to use
+     * @returns The same value as {@link node}
+     */
   add(node, comp) {
     const { next } = this;
-    if (next && comp(node.value, next.value) > 0)
+    if (next && comp(node.value, next.value) >= 0)
       return next.add(node, comp);
     this.next = node;
     node.prev = this;
@@ -120,7 +123,6 @@ class Extractor {
       name
     });
   }
-  ctx;
   Joint = Joint.bind(this);
   Fallback = Fallback.bind(this);
   Dest = Dest.bind(this);
@@ -193,7 +195,10 @@ function Source(props) {
   };
   const node = new OrderedLinkedListNode(info);
   createRenderEffect(on(order, () => {
-    onCleanup(() => node.remove());
+    onCleanup(() => {
+      node.remove();
+      state.force();
+    });
     sources.add(node, COMPARATOR);
     state.force();
   }));

package/dist/index.umd.js

@@ -2,10 +2,12 @@
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("solid-js")) : typeof define === "function" && define.amd ? define(["exports", "solid-js"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.solidCtrlFlow = {}, global.solidJs));
 })(this, function(exports2, solidJs) {
   "use strict";
+  const NO_OP = () => {
+  };
   function memoProps(obj, keys = Reflect.ownKeys(obj), equals = false) {
     const out = {};
     for (const elm of keys)
-      Object.defineProperty(out, elm, { enumerable: true, get: solidJs.createMemo(() => obj[elm], void 0, { equals }) });
+      Object.defineProperty(out, elm, { enumerable: true, set: NO_OP, get: solidJs.createMemo(() => obj[elm], void 0, { equals }) });
     return out;
   }
   const splitAndMemoProps = (obj, ...keys) => {
@@ -62,14 +64,15 @@
       yield* next;
     }
     /**
-     * Adds a node to the list in order
-     * @param node The node to add
-     * @param comp The comparison function to use
-     * @returns The same value as {@link node}
-     */
+       * Adds a node to the list in order.
+    * If two nodes have the same order, it would have been more efficient to put the latest one first, but this would not have been ok, since we also want to order by insertion time
+       * @param node The node to add
+       * @param comp The comparison function to use
+       * @returns The same value as {@link node}
+       */
     add(node, comp) {
       const { next } = this;
-      if (next && comp(node.value, next.value) > 0)
+      if (next && comp(node.value, next.value) >= 0)
         return next.add(node, comp);
       this.next = node;
       node.prev = this;
@@ -123,7 +126,6 @@
         name
       });
     }
-    ctx;
     Joint = Joint.bind(this);
     Fallback = Fallback.bind(this);
     Dest = Dest.bind(this);
@@ -196,7 +198,10 @@
     };
     const node = new OrderedLinkedListNode(info);
     solidJs.createRenderEffect(solidJs.on(order, () => {
-      solidJs.onCleanup(() => node.remove());
+      solidJs.onCleanup(() => {
+        node.remove();
+        state.force();
+      });
       sources.add(node, COMPARATOR);
       state.force();
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-ctrl-flow",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "description": "Control flow components for solid-js",
   "author": "AFatNiBBa",
   "license": "ISC",