websites: restructured

.zed/settings.json

@@ -12,9 +12,11 @@
     "**/.settings",
     // custom
     "**/lean-qr/*/index.mjs",
+    "**/modern-screenshot/*/index.mjs",
+    "**/solidjs-signals/*/dist/prod.js",
     "uFuzzy.mjs",
     "lightweight-charts.standalone.production.mjs",
-    "**/modern-screenshot/*/index.mjs",
-    "**/solidjs-signals/*/dist/prod.js"
+    "scripts/packages",
+    "dist"
   ]
 }

Cargo.lock

@@ -4133,9 +4133,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.225"
+version = "1.0.226"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6c24dee235d0da097043389623fb913daddf92c76e9f5a1db88607a0bcbd1d"
+checksum = "0dca6411025b24b60bfa7ec1fe1f8e710ac09782dca409ee8237ba74b51295fd"
 dependencies = [
  "serde_core",
  "serde_derive",
@@ -4153,18 +4153,18 @@ dependencies = [
 
 [[package]]
 name = "serde_core"
-version = "1.0.225"
+version = "1.0.226"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "659356f9a0cb1e529b24c01e43ad2bdf520ec4ceaf83047b83ddcc2251f96383"
+checksum = "ba2ba63999edb9dac981fb34b3e5c0d111a69b0924e253ed29d83f7c99e966a4"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.225"
+version = "1.0.226"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea936adf78b1f766949a4977b91d2f5595825bd6ec079aa9543ad2685fc4516"
+checksum = "8db53ae22f34573731bafa1db20f04027b2d25e02d8205921b569171699cdb33"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -67,9 +67,9 @@ minreq = { version = "2.14.1", features = ["https", "serde_json"] }
 parking_lot = "0.12.4"
 quick_cache = "0.6.16"
 rayon = "1.11.0"
-serde = "1.0.225"
+serde = "1.0.226"
 serde_bytes = "0.11.19"
-serde_derive = "1.0.225"
+serde_derive = "1.0.226"
 serde_json = { version = "1.0.145", features = ["float_roundtrip"] }
 sonic-rs = "0.5.4"
 tokio = { version = "1.47.1", features = ["rt-multi-thread"] }

crates/brk_bundler/src/lib.rs

@@ -15,19 +15,39 @@ use tokio::sync::Mutex;
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> io::Result<PathBuf> {
-    let source_path = websites_path.join(source_folder);
-    let dist_path = websites_path.join("dist");
-
-    let _ = fs::remove_dir_all(&dist_path);
-    copy_dir_all(&source_path, &dist_path)?;
-
-    let source_scripts = format!("./{source_folder}/scripts");
-    let source_entry = format!("{source_scripts}/entry.js");
+    let relative_source_path = websites_path.join(source_folder);
+    let relative_dist_path = websites_path.join("dist");
+    let relative_packages_path = websites_path.join("packages");
 
     let absolute_websites_path = websites_path.absolutize();
+    let absolute_websites_path_clone = absolute_websites_path.clone();
+
+    let absolute_packages_path = relative_packages_path.absolutize();
+
+    let absolute_source_path = relative_source_path.absolutize();
+    let absolute_source_index_path = absolute_source_path.join("index.html");
+    let absolute_source_index_path_clone = absolute_source_index_path.clone();
+    let absolute_source_scripts_path = absolute_source_path.join("scripts");
+    let absolute_source_scripts_packages_path = absolute_source_scripts_path.join("packages");
+    let absolute_source_sw_path = absolute_source_path.join("service-worker.js");
+    let absolute_source_sw_path_clone = absolute_source_sw_path.clone();
+
+    let absolute_dist_path = relative_dist_path.absolutize();
+    let absolute_dist_scripts_entry_path = absolute_dist_path.join("scripts/entry.js");
+    let absolute_dist_scripts_entry_path_clone = absolute_dist_scripts_entry_path.clone();
+    let absolute_dist_index_path = absolute_dist_path.join("index.html");
+    let absolute_dist_sw_path = absolute_dist_path.join("service-worker.js");
+
+    let _ = fs::remove_dir_all(&absolute_dist_path);
+    let _ = fs::remove_dir_all(&absolute_source_scripts_packages_path);
+    copy_dir_all(
+        &absolute_packages_path,
+        &absolute_source_scripts_packages_path,
+    )?;
+    copy_dir_all(&absolute_source_path, &absolute_dist_path)?;
 
     let mut bundler = Bundler::new(BundlerOptions {
-        input: Some(vec![source_entry.into()]),
+        input: Some(vec![format!("./{source_folder}/scripts/entry.js").into()]),
         dir: Some("./dist/scripts".to_string()),
         cwd: Some(absolute_websites_path),
         minify: Some(RawMinifyOptions::Bool(true)),
@@ -39,24 +59,10 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
         error!("{error:?}");
     }
 
-    let absolute_source_index_path = source_path.join("index.html").absolutize();
-    let absolute_source_index_path_clone = absolute_source_index_path.clone();
-    let absolute_source_path = source_path.absolutize();
-    let absolute_source_path_clone = absolute_source_path.clone();
-    let absolute_source_scripts_path = websites_path.join(source_scripts).absolutize();
-    let absolute_source_sw_path = source_path.join("service-worker.js").absolutize();
-    let absolute_source_sw_path_clone = absolute_source_sw_path.clone();
-
-    let absolute_dist_entry_path = dist_path.join("scripts/entry.js").absolutize();
-    let absolute_dist_index_path = dist_path.join("index.html").absolutize();
-    let absolute_dist_path = dist_path.absolutize();
-    let absolute_dist_path_clone = absolute_dist_path.clone();
-    let absolute_dist_sw_path = dist_path.join("service-worker.js").absolutize();
-
     let write_index = move || {
         let mut contents = fs::read_to_string(&absolute_source_index_path).unwrap();
 
-        if let Ok(entry) = fs::read_to_string(absolute_dist_path_clone.join("scripts/entry.js"))
+        if let Ok(entry) = fs::read_to_string(&absolute_dist_scripts_entry_path_clone)
             && let Some(start) = entry.find("main")
             && let Some(end) = entry.find(".js")
         {
@@ -78,25 +84,13 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
     write_sw();
 
     if !watch {
-        return Ok(dist_path);
+        return Ok(relative_dist_path);
     }
 
     tokio::spawn(async move {
-        let write_index_clone = write_index.clone();
+        let absolute_websites_path = absolute_websites_path_clone.clone();
 
-        let mut entry_watcher = notify::recommended_watcher(
-            move |res: Result<notify::Event, notify::Error>| match res {
-                Ok(_) => write_index_clone(),
-                Err(e) => error!("watch error: {e:?}"),
-            },
-        )
-        .unwrap();
-
-        entry_watcher
-            .watch(&absolute_dist_entry_path, RecursiveMode::Recursive)
-            .unwrap();
-
-        let mut source_watcher = notify::recommended_watcher(
+        let mut event_watcher = notify::recommended_watcher(
             move |res: Result<notify::Event, notify::Error>| match res {
                 Ok(event) => match event.kind {
                     EventKind::Create(_) => event.paths,
@@ -104,18 +98,33 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
                     _ => vec![],
                 }
                 .into_iter()
-                .filter(|path| path.starts_with(&absolute_source_path))
-                .filter(|path| !path.starts_with(&absolute_source_scripts_path))
-                .for_each(|source_path| {
-                    let suffix = source_path.strip_prefix(&absolute_source_path).unwrap();
-                    let dist_path = absolute_dist_path.join(suffix);
-
-                    if source_path == absolute_source_index_path_clone {
+                .for_each(|path| {
+                    if path == absolute_dist_scripts_entry_path
+                        || path == absolute_source_index_path_clone
+                    {
                         write_index();
-                    } else if source_path == absolute_source_sw_path_clone {
+                    } else if path == absolute_source_sw_path_clone {
                         write_sw();
-                    } else {
-                        let _ = fs::copy(&source_path, &dist_path);
+                    } else if path.starts_with(&absolute_packages_path) {
+                        let suffix = path.strip_prefix(&absolute_websites_path).unwrap();
+                        let dist_path = absolute_source_scripts_path.join(suffix);
+
+                        dbg!(&suffix, &dist_path);
+                        if path.is_file() {
+                            let _ = fs::create_dir_all(path.parent().unwrap());
+                            let _ = fs::copy(&path, &dist_path);
+                        }
+                    } else if path.starts_with(&absolute_source_path)
+                        // scripts are handled by rolldown
+                        && !path.starts_with(&absolute_source_scripts_path)
+                    {
+                        let suffix = path.strip_prefix(&absolute_source_path).unwrap();
+                        let dist_path = absolute_dist_path.join(suffix);
+
+                        if path.is_file() {
+                            let _ = fs::create_dir_all(path.parent().unwrap());
+                            let _ = fs::copy(&path, &dist_path);
+                        }
                     }
                 }),
                 Err(e) => error!("watch error: {e:?}"),
@@ -123,8 +132,8 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
         )
         .unwrap();
 
-        source_watcher
-            .watch(&absolute_source_path_clone, RecursiveMode::Recursive)
+        event_watcher
+            .watch(&absolute_websites_path_clone, RecursiveMode::Recursive)
             .unwrap();
 
         let watcher =
@@ -133,7 +142,7 @@ pub async fn bundle(websites_path: &Path, source_folder: &str, watch: bool) -> i
         watcher.start().await;
     });
 
-    Ok(dist_path)
+    Ok(relative_dist_path)
 }
 
 fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> io::Result<()> {

websites/.gitignore

@@ -0,0 +1 @@
+**/scripts/packages

websites/bitview/jsconfig.json

@@ -6,5 +6,5 @@
     "module": "ESNext",
     "skipLibCheck": true
   },
-  "exclude": ["assets", "packages", "ignore"]
+  "exclude": ["assets", "scripts/packages", "scripts/bridge"]
 }

websites/bitview/scripts/main.js

@@ -2,12 +2,12 @@
 
 /**
  * @import { Option, PartialChartOption, ChartOption, AnyPartialOption, ProcessedOptionAddons, OptionsTree, SimulationOption, AnySeriesBlueprint, SeriesType } from "./options"
- * @import { Valued,  SingleValueData, CandlestickData, OHLCTuple, Series, ISeries, HistogramData, LineData, BaselineData, LineSeriesPartialOptions, BaselineSeriesPartialOptions, HistogramSeriesPartialOptions, CandlestickSeriesPartialOptions } from "../packages/lightweight-charts/wrapper"
- * @import * as _ from "../packages/leeoniya-ufuzzy/1.0.19/dist/uFuzzy.d.ts"
+ * @import { Valued,  SingleValueData, CandlestickData, OHLCTuple, Series, ISeries, HistogramData, LineData, BaselineData, LineSeriesPartialOptions, BaselineSeriesPartialOptions, HistogramSeriesPartialOptions, CandlestickSeriesPartialOptions } from "./packages/lightweight-charts/wrapper"
+ * @import * as _ from "./packages/leeoniya-ufuzzy/1.0.19/dist/uFuzzy.d.ts"
  * @import { SerializedChartableIndex } from "./chart";
- * @import { Signal, Signals, Accessor } from "../packages/solidjs-signals/wrapper";
+ * @import { Signal, Signals, Accessor } from "./packages/solidjs-signals/wrapper";
  * @import { DateIndex, DecadeIndex, DifficultyEpoch, Index, HalvingEpoch, Height, MonthIndex, P2PK33AddressIndex, P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2MSOutputIndex, P2AAddressIndex, P2TRAddressIndex, P2WPKHAddressIndex, P2WSHAddressIndex, TxIndex, InputIndex, OutputIndex, VecId, WeekIndex, SemesterIndex, YearIndex, VecIdToIndexes, QuarterIndex, EmptyOutputIndex, OpReturnIndex, UnknownOutputIndex, EmptyAddressIndex, LoadedAddressIndex } from "./bridge/vecs"
- * @import { Pools, Pool} from "./bridge/pools"
+ * @import { Pools, Pool } from "./bridge/pools"
  */
 
 /**
@@ -72,27 +72,27 @@ const localhost = window.location.hostname === "localhost";
 function initPackages() {
   const imports = {
     async signals() {
-      return import("../packages/solidjs-signals/wrapper.js").then(
+      return import("./packages/solidjs-signals/wrapper.js").then(
         (d) => d.default,
       );
     },
     async lightweightCharts() {
       return window.document.fonts.ready.then(() =>
-        import("../packages/lightweight-charts/wrapper.js").then(
+        import("./packages/lightweight-charts/wrapper.js").then(
           (d) => d.default,
         ),
       );
     },
     async leanQr() {
-      return import("../packages/lean-qr/2.5.0/index.mjs").then((d) => d);
+      return import("./packages/lean-qr/2.5.0/index.mjs").then((d) => d);
     },
     async ufuzzy() {
-      return import("../packages/leeoniya-ufuzzy/1.0.19/dist/uFuzzy.mjs").then(
+      return import("./packages/leeoniya-ufuzzy/1.0.19/dist/uFuzzy.mjs").then(
         ({ default: d }) => d,
       );
     },
     async modernScreenshot() {
-      return import("../packages/modern-screenshot/wrapper.js").then((d) => d);
+      return import("./packages/modern-screenshot/wrapper.js").then((d) => d);
     },
   };
 

websites/bitview/tsconfig.json

@@ -9,5 +9,5 @@
     "lib": ["DOM", "DOM.Iterable", "ESNext", "WebWorker"],
     "skipLibCheck": true
   },
-  "exclude": ["assets", "packages", "ignore"]
+  "exclude": ["assets", "scripts/packages", "scripts/bridge"]
 }

websites/packages/.gitignore

@@ -1,5 +1,5 @@
 LICENSE
-*.json
+*/**/*.json
 *webcomponent*
 README*.md
 cli*

websites/packages/jsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "checkJs": true,
+    "strict": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "skipLibCheck": true
+  },
+  "exclude": ["scripts/packages", "scripts/bridge", "spmething"]
+}

websites/packages/modern-screenshot/wrapper.js

@@ -1,18 +1,24 @@
 import { domToBlob } from "./4.6.6/dist/index.mjs";
 
+const userAgent = navigator.userAgent.toLowerCase();
+const iphone = userAgent.includes("iphone");
+const ipad = userAgent.includes("ipad");
+const ios = iphone || ipad;
+
+console.log({ ios });
+
 /**
  * @param {Object} args
  * @param {Element} args.element
  * @param {string} args.name
  * @param {string} args.title
- * @param {Env} args.env
  */
-export async function screenshot({ element, name, title, env }) {
+export async function screenshot({ element, name, title }) {
   const blob = await domToBlob(element, {
     scale: 2,
   });
 
-  if (env.ios) {
+  if (ios) {
     const file = new File(
       [blob],
       `bitview-${name}-${new Date().toJSON().split(".")[0]}.png`,

websites/packages/solidjs-signals/0.4.11/dist/types/boundaries.d.ts

@@ -0,0 +1,22 @@
+import { Computation, Queue } from "./core/index.js";
+import type { Effect } from "./core/index.js";
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _nodes: Set<Effect>;
+    _disabled: Computation<boolean>;
+    constructor(type: number);
+    run(type: number): void;
+    notify(node: Effect, type: number, flags: number): any;
+    merge(queue: CollectionQueue): void;
+}
+export declare enum BoundaryMode {
+    VISIBLE = "visible",
+    HIDDEN = "hidden"
+}
+export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
+export declare function createSuspense(fn: () => any, fallback: () => any): () => any;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => any;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;

websites/packages/solidjs-signals/0.4.11/dist/types/core/constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * See https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph
+ * State clean corresponds to a node where all the sources are fully up to date
+ * State check corresponds to a node where some sources (including grandparents) may have changed
+ * State dirty corresponds to a node where the direct parents of a node has changed
+ */
+export declare const STATE_CLEAN = 0;
+export declare const STATE_CHECK = 1;
+export declare const STATE_DIRTY = 2;
+export declare const STATE_DISPOSED = 3;
+export declare const EFFECT_PURE = 0;
+export declare const EFFECT_RENDER = 1;
+export declare const EFFECT_USER = 2;
+export declare const SUPPORTS_PROXY: boolean;

websites/packages/solidjs-signals/0.4.11/dist/types/core/core.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Nodes for constructing a graph of reactive values and reactive computations.
+ *
+ * - The graph is acyclic.
+ * - The user inputs new values into the graph by calling .write() on one more computation nodes.
+ * - The user retrieves computed results from the graph by calling .read() on one or more computation nodes.
+ * - The library is responsible for running any necessary computations so that .read() is up to date
+ *   with all prior .write() calls anywhere in the graph.
+ * - We call the input nodes 'roots' and the output nodes 'leaves' of the graph here.
+ * - Changes flow from roots to leaves. It would be effective but inefficient to immediately
+ *   propagate all changes from a root through the graph to descendant leaves. Instead, we defer
+ *   change most change propagation computation until a leaf is accessed. This allows us to
+ *   coalesce computations and skip altogether recalculating unused sections of the graph.
+ * - Each computation node tracks its sources and its observers (observers are other
+ *   elements that have this node as a source). Source and observer links are updated automatically
+ *   as observer computations re-evaluate and call get() on their sources.
+ * - Each node stores a cache state (clean/check/dirty) to support the change propagation algorithm:
+ *
+ * In general, execution proceeds in three passes:
+ *
+ *  1. write() propagates changes down the graph to the leaves
+ *     direct children are marked as dirty and their deeper descendants marked as check
+ *     (no computations are evaluated)
+ *  2. read() requests that parent nodes updateIfNecessary(), which proceeds recursively up the tree
+ *     to decide whether the node is clean (parents unchanged) or dirty (parents changed)
+ *  3. updateIfNecessary() evaluates the computation if the node is dirty (the computations are
+ *     executed in root to leaf order)
+ */
+import { type Flags } from "./flags.js";
+import { Owner } from "./owner.js";
+import { type Transition } from "./scheduler.js";
+export interface SignalOptions<T> {
+    id?: string;
+    name?: string;
+    equals?: ((prev: T, next: T) => boolean) | false;
+    pureWrite?: boolean;
+    unobserved?: () => void;
+}
+export interface SourceType {
+    _observers: ObserverType[] | null;
+    _unobserved?: () => void;
+    _updateIfNecessary: () => void;
+    _stateFlags: Flags;
+    _time: number;
+    _transition?: Transition;
+    _cloned?: Computation;
+}
+export interface ObserverType {
+    _sources: SourceType[] | null;
+    _notify: (state: number, skipQueue?: boolean) => void;
+    _handlerMask: Flags;
+    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
+    _time: number;
+    _cloned?: Computation;
+}
+/**
+ * Returns the current observer.
+ */
+export declare function getObserver(): Computation | null;
+export declare const UNCHANGED: unique symbol;
+export type UNCHANGED = typeof UNCHANGED;
+export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
+    _sources: SourceType[] | null;
+    _observers: ObserverType[] | null;
+    _value: T | undefined;
+    _error: unknown;
+    _compute: null | ((p?: T) => T);
+    _name: string | undefined;
+    _equals: false | ((a: T, b: T) => boolean);
+    _unobserved: (() => void) | undefined;
+    _pureWrite: boolean;
+    /** Whether the computation is an error or has ancestors that are unresolved */
+    _stateFlags: number;
+    /** Which flags raised by sources are handled, vs. being passed through. */
+    _handlerMask: number;
+    _time: number;
+    _forceNotify: boolean;
+    _transition?: Transition | undefined;
+    _cloned?: Computation;
+    constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
+    _read(): T;
+    /**
+     * Return the current value of this computation
+     * Automatically re-executes the surrounding computation when the value changes
+     */
+    read(): T;
+    /**
+     * Return the current value of this computation
+     * Automatically re-executes the surrounding computation when the value changes
+     *
+     * If the computation has any unresolved ancestors, this function waits for the value to resolve
+     * before continuing
+     */
+    wait(): T;
+    /** Update the computation with a new value. */
+    write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
+    /**
+     * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
+     */
+    _notify(state: number, skipQueue?: boolean): void;
+    /**
+     * Notify the computation that one of its sources has changed flags.
+     *
+     * @param mask A bitmask for which flag(s) were changed.
+     * @param newFlags The source's new flags, masked to just the changed ones.
+     */
+    _notifyFlags(mask: Flags, newFlags: Flags): void;
+    _setError(error: unknown): void;
+    /**
+     * This is the core part of the reactivity system, which makes sure that the values are updated
+     * before they are read. We've also adapted it to return the loading state of the computation,
+     * so that we can propagate that to the computation's observers.
+     *
+     * This function will ensure that the value and states we read from the computation are up to date
+     */
+    _updateIfNecessary(): void;
+    /**
+     * Remove ourselves from the owner graph and the computation graph
+     */
+    _disposeNode(): void;
+}
+/**
+ * Reruns a computation's _compute function, producing a new value and keeping track of dependencies.
+ *
+ * It handles the updating of sources and observers, disposal of previous executions,
+ * and error handling if the _compute function throws. It also sets the node as loading
+ * if it reads any parents that are currently loading.
+ */
+export declare function update<T>(node: Computation<T>): void;
+export declare function isEqual<T>(a: T, b: T): boolean;
+/**
+ * Returns the current value stored inside the given compute function without triggering any
+ * dependencies. Use `untrack` if you want to also disable owner tracking.
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Returns true if the given functinon contains signals that have been updated since the last time
+ * the parent computation was run.
+ */
+export declare function hasUpdated(fn: () => any): boolean;
+/**
+ * Returns an accessor that is true if the given function contains async signals that are out of date.
+ */
+export declare function isPending(fn: () => any): boolean;
+export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
+/**
+ * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
+ */
+export declare function latest<T>(fn: () => T): T;
+export declare function latest<T, U>(fn: () => T, fallback: U): T | U;
+/**
+ * Runs the given function in the given observer.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithObserver<T>(observer: Computation, run: () => T): T | undefined;
+/**
+ * A convenient wrapper that calls `compute` with the `owner` and `observer` and is guaranteed
+ * to reset the global context after the computation is finished even if an error is thrown.
+ */
+export declare function compute<T>(owner: Owner | null, fn: (val: T) => T, observer: Computation<T>): T;
+export declare function compute<T>(owner: Owner | null, fn: (val: undefined) => T, observer: null): T;

websites/packages/solidjs-signals/0.4.11/dist/types/core/effect.d.ts

@@ -0,0 +1,39 @@
+import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { Computation, type SignalOptions } from "./core.js";
+import { type Flags } from "./flags.js";
+/**
+ * Effects are the leaf nodes of our reactive graph. When their sources change, they are
+ * automatically added to the queue of effects to re-execute, which will cause them to fetch their
+ * sources and recompute
+ */
+export declare class Effect<T = any> extends Computation<T> {
+    _effect: (val: T, prev: T | undefined) => void | (() => void);
+    _onerror: ((err: unknown, cleanup: () => void) => void) | undefined;
+    _cleanup: (() => void) | undefined;
+    _modified: boolean;
+    _prevValue: T | undefined;
+    _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
+    constructor(initialValue: T, compute: (val?: T) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown) => void | (() => void), options?: SignalOptions<T> & {
+        render?: boolean;
+        defer?: boolean;
+    });
+    write(value: T, flags?: number): T;
+    _notify(state: number, skipQueue?: boolean): void;
+    _notifyFlags(mask: Flags, newFlags: Flags): void;
+    _setError(error: unknown): void;
+    _disposeNode(): void;
+    _run(type: number): void;
+}
+export declare class EagerComputation<T = any> extends Computation<T> {
+    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
+        defer?: boolean;
+    });
+    _notify(state: number, skipQueue?: boolean): void;
+    _run(): void;
+}
+export declare class FirewallComputation extends Computation {
+    firewall: boolean;
+    constructor(compute: () => void);
+    _notify(state: number, skipQueue?: boolean): void;
+    _run(): void;
+}

websites/packages/solidjs-signals/0.4.11/dist/types/core/error.d.ts

@@ -0,0 +1,8 @@
+export declare class NotReadyError extends Error {
+}
+export declare class NoOwnerError extends Error {
+    constructor();
+}
+export declare class ContextNotFoundError extends Error {
+    constructor();
+}

websites/packages/solidjs-signals/0.4.11/dist/types/core/flags.d.ts

@@ -0,0 +1,11 @@
+export type Flags = number;
+export declare const ERROR_OFFSET = 0;
+export declare const ERROR_BIT: number;
+export declare const ERROR: unique symbol;
+export declare const LOADING_OFFSET = 1;
+export declare const LOADING_BIT: number;
+export declare const LOADING: unique symbol;
+export declare const UNINITIALIZED_OFFSET = 2;
+export declare const UNINITIALIZED_BIT: number;
+export declare const UNINITIALIZED: unique symbol;
+export declare const DEFAULT_FLAGS: number;

websites/packages/solidjs-signals/0.4.11/dist/types/core/index.d.ts

@@ -0,0 +1,7 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
+export { Owner, createContext, getContext, setContext, hasContext, getOwner, onCleanup, type Context, type ContextRecord, type Disposable } from "./owner.js";
+export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
+export { Effect, EagerComputation } from "./effect.js";
+export { flush, Queue, incrementClock, transition, ActiveTransition, type IQueue } from "./scheduler.js";
+export * from "./constants.js";
+export * from "./flags.js";

websites/packages/solidjs-signals/0.4.11/dist/types/core/owner.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Owner tracking is used to enable nested tracking scopes with automatic cleanup.
+ * We also use owners to also keep track of which error handling context we are in.
+ *
+ * If you write the following
+ *
+ *   const a = createOwner(() => {
+ *     const b = createOwner(() => {});
+ *
+ *     const c = createOwner(() => {
+ *       const d = createOwner(() => {});
+ *     });
+ *
+ *     const e = createOwner(() => {});
+ *   });
+ *
+ * The owner tree will look like this:
+ *
+ *    a
+ *   /|\
+ *  b-c-e
+ *    |
+ *    d
+ *
+ * Following the _nextSibling pointers of each owner will first give you its children, and then its siblings (in reverse).
+ * a -> e -> c -> d -> b
+ *
+ * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
+ */
+import { type IQueue } from "./scheduler.js";
+export type ContextRecord = Record<string | symbol, unknown>;
+export interface Disposable {
+    (): void;
+}
+/**
+ * Returns the currently executing parent owner.
+ */
+export declare function getOwner(): Owner | null;
+export declare function setOwner(owner: Owner | null): Owner | null;
+export declare class Owner {
+    _parent: Owner | null;
+    _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
+    _state: number;
+    _disposal: Disposable | Disposable[] | null;
+    _context: ContextRecord;
+    _queue: IQueue;
+    _childCount: number;
+    id: string | null;
+    constructor(id?: string | null, skipAppend?: boolean);
+    append(child: Owner): void;
+    dispose(this: Owner, self?: boolean): void;
+    _disposeNode(): void;
+    emptyDisposal(): void;
+    getNextChildId(): string;
+}
+export interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T | undefined;
+}
+/**
+ * Context provides a form of dependency injection. It is used to save from needing to pass
+ * data as props through intermediate components. This function creates a new context object
+ * that can be used with `getContext` and `setContext`.
+ *
+ * A default value can be provided here which will be used when a specific value is not provided
+ * via a `setContext` call.
+ */
+export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
+/**
+ * Attempts to get a context value for the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ */
+export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+/**
+ * Attempts to set a context value on the parent scope with the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ */
+export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;
+/**
+ * Whether the given context is currently defined.
+ */
+export declare function hasContext(context: Context<any>, owner?: Owner | null): boolean;
+/**
+ * Runs an effect once before the reactive scope is disposed
+ * @param fn an effect that should run only once on cleanup
+ *
+ * @returns the same {@link fn} function that was passed in
+ *
+ * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
+ */
+export declare function onCleanup(fn: Disposable): Disposable;

websites/packages/solidjs-signals/0.4.11/dist/types/core/scheduler.d.ts

@@ -0,0 +1,85 @@
+import type { Computation, ObserverType, SourceType } from "./core.js";
+import type { Effect } from "./effect.js";
+export declare let clock: number;
+export declare function incrementClock(): void;
+export declare let ActiveTransition: Transition | null;
+export declare let Unobserved: SourceType[];
+export type QueueCallback = (type: number) => void;
+export interface IQueue {
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): boolean | void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    created: number;
+    notify(...args: any[]): boolean;
+    merge(queue: IQueue): void;
+    _parent: IQueue | null;
+    _cloned?: IQueue | undefined;
+}
+export declare class Queue implements IQueue {
+    _parent: IQueue | null;
+    _running: boolean;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: IQueue[];
+    created: number;
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): any;
+    removeChild(child: IQueue): any;
+    notify(...args: any[]): any;
+    merge(queue: Queue): void;
+}
+export declare const globalQueue: Queue;
+/**
+ * By default, changes are batched on the microtask queue which is an async process. You can flush
+ * the queue synchronously to get the latest updates by calling `flush()`.
+ */
+export declare function flush(): void;
+export declare function removeSourceObservers(node: ObserverType, index: number): void;
+export declare class Transition implements IQueue {
+    _sources: Map<Computation, Computation>;
+    _pendingNodes: Set<Effect>;
+    _promises: Set<Promise<any>>;
+    _optimistic: Set<(() => void) & {
+        _transition?: Transition;
+    }>;
+    _done: Transition | boolean;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _clonedQueues: Map<Queue, Queue>;
+    _pureQueue: QueueCallback[];
+    _children: IQueue[];
+    _parent: IQueue | null;
+    _running: boolean;
+    _scheduled: boolean;
+    _cloned: Queue;
+    created: number;
+    constructor();
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(node: Effect, type: number, flags: number): boolean;
+    merge(queue: Transition): void;
+    schedule(): void;
+    runTransition(fn: () => any | Promise<any>, force?: boolean): void;
+    addOptimistic(fn: (() => void) & {
+        _transition?: Transition;
+    }): void;
+}
+/**
+ * Runs the given function in a transition scope, allowing for batch updates and optimizations.
+ * This is useful for grouping multiple state updates together to avoid unnecessary re-renders.
+ *
+ * @param fn A function that receives a resume function to continue the transition.
+ * The resume function can be called with another function to continue the transition.
+ *
+ * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
+ */
+export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any>): void;
+export declare function cloneGraph(node: Computation): Computation;
+export declare function getOGSource<T extends Computation>(input: T): T;
+export declare function getTransitionSource<T extends Computation>(input: T): T;
+export declare function initialDispose(node: any): void;

websites/packages/solidjs-signals/0.4.11/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, runWithObserver, transition, SUPPORTS_PROXY } from "./core/index.js";
+export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+export { mapArray, repeat, type Maybe } from "./map.js";
+export * from "./signals.js";
+export * from "./store/index.js";
+export { createSuspense, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";

websites/packages/solidjs-signals/0.4.11/dist/types/map.d.ts

@@ -0,0 +1,22 @@
+import type { Accessor } from "./signals.js";
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ *
+ * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ */
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: boolean | ((item: Item) => any);
+    fallback?: Accessor<any>;
+}): Accessor<MappedItem[]>;
+/**
+ * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */
+export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
+    from?: Accessor<number | undefined>;
+    fallback?: Accessor<any>;
+}): Accessor<any[]>;

websites/packages/solidjs-signals/0.4.11/dist/types/signals.d.ts

@@ -0,0 +1,173 @@
+import type { SignalOptions } from "./core/index.js";
+import { Owner } from "./core/index.js";
+export type Accessor<T> = () => T;
+export type Setter<in out T> = {
+    <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
+    <U extends T>(value: (prev: T) => U): U;
+    <U extends T>(value: Exclude<U, Function>): U;
+    <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
+};
+export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
+export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
+export type EffectBundle<Prev, Next extends Prev = Prev> = {
+    effect: EffectFunction<Prev, Next>;
+    error: (err: unknown, cleanup: () => void) => void;
+};
+export interface EffectOptions {
+    name?: string;
+    defer?: boolean;
+}
+export interface MemoOptions<T> {
+    name?: string;
+    equals?: false | ((prev: T, next: T) => boolean);
+}
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+/**
+ * Creates a simple reactive state with a getter and setter
+ * ```typescript
+ * const [state: Accessor<T>, setState: Setter<T>] = createSignal<T>(
+ *  value: T,
+ *  options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * )
+ * ```
+ * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
+ * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+ *
+ * @returns ```typescript
+ * [state: Accessor<T>, setState: Setter<T>]
+ * ```
+ * * the Accessor is a function that returns the current value and registers each call to the reactive root
+ * * the Setter is a function that allows directly setting or mutating the value:
+ * ```typescript
+ * const [count, setCount] = createSignal(0);
+ * setCount(count => count + 1);
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
+ */
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Creates a readonly derived reactive memoized signal
+ * ```typescript
+ * export function createMemo<T>(
+ *   compute: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
+ */
+export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+/**
+ * Creates a readonly derived async reactive memoized signal
+ * ```typescript
+ * export function createAsync<T>(
+ *   compute: (v: T) => Promise<T> | T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-async
+ */
+export declare function createAsync<T>(compute: (prev: T | undefined, refreshing: boolean) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T> & {
+    refresh: () => void;
+};
+/**
+ * Creates a reactive effect that runs after the render phase
+ * ```typescript
+ * export function createEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param effect a function that receives the new value and is used to perform side effects, return a cleanup function to run on disposal
+ * @param error an optional function that receives an error if thrown during the computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */
+export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param effect a function that receives the new value and is used to perform side effects
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */
+export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>): void;
+export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id: string;
+}): T;
+/**
+ * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
+ * This method untracks the current scope.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;
+/**
+ * Returns a promise of the resolved value of a reactive expression
+ * @param fn a reactive expression to resolve
+ */
+export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Runs the given function and returns a tuple with the result or an error.
+ * If the function throws an error, it will be caught and returned as the first element of the tuple.
+ * If the function returns a promise, it will resolve to a tuple with the result or an error.
+ *
+ * @param fn The function to run.
+ * @returns A tuple with either [undefined, result] or [error].
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/try-catch
+ */
+export type TryCatchResult<T, E> = [undefined, T] | [E];
+export declare function tryCatch<T, E = Error>(fn: () => Promise<T>): Promise<TryCatchResult<T, E>>;
+export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E>;
+/**
+ * Creates an optimistic signal that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ *
+ * @param initial The initial value of the signal.
+ * @param compute An optional function to compute the next value based on the previous value and change.
+ * @param options Optional signal options.
+ *
+ * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
+ */
+export declare function createOptimistic<T>(initial: Exclude<T, Function>, compute?: never): [Accessor<T>, (value: T | ((v?: T) => T)) => void];
+export declare function createOptimistic<T extends object, U>(initial: T | Accessor<T>, compute: (prev: T, change: U) => void, key: string | ((item: any) => any)): [Accessor<T>, (value: U | ((v?: U) => U)) => void];

websites/packages/solidjs-signals/0.4.11/dist/types/store/index.d.ts

@@ -0,0 +1,6 @@
+export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./store.js";
+export type { Merge, Omit } from "./utils.js";
+export { isWrappable, createStore, deep, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { createProjection } from "./projection.js";
+export { reconcile } from "./reconcile.js";
+export { snapshot, merge, omit } from "./utils.js";

websites/packages/solidjs-signals/0.4.11/dist/types/store/projection.d.ts

@@ -0,0 +1,7 @@
+import { type Store } from "./store.js";
+/**
+ * Creates a mutable derived value
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */
+export declare function createProjection<T extends Object>(fn: (draft: T) => void, initialValue?: T): Store<T>;

websites/packages/solidjs-signals/0.4.11/dist/types/store/reconcile.d.ts

@@ -0,0 +1 @@
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any), all?: boolean): (state: U) => void;

websites/packages/solidjs-signals/0.4.11/dist/types/store/store.d.ts

@@ -0,0 +1,33 @@
+import { Computation } from "../core/index.js";
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => void) => void;
+type DataNode = Computation<any>;
+type DataNodes = Record<PropertyKey, DataNode>;
+export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l";
+export type StoreNode = {
+    [$PROXY]: any;
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
+    [STORE_LOOKUP]?: WeakMap<any, any>;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: Record<PropertyKey, any>): any;
+export declare const storeLookup: WeakMap<object, any>;
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+export declare const storeTraps: ProxyHandler<StoreNode>;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => void): void;
+export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function deep<T extends object>(store: Store<T>): Store<any>;
+export {};

websites/packages/solidjs-signals/0.4.11/dist/types/store/utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Returns a non reactive copy of the store object.
+ * It will attempt to preserver the original reference unless the value has been modified.
+ * @param item store proxy object
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};

websites/packages/solidjs-signals/wrapper.js

@@ -1,9 +1,9 @@
 // @ts-check
 
 /**
- * @import { SignalOptions } from "./0.4.1/dist/types/core/core"
- * @import { getOwner as GetOwner, onCleanup as OnCleanup } from "./0.4.1/dist/types/core/owner"
- * @import { createSignal as CreateSignal, createEffect as CreateEffect, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner, Setter } from "./0.4.1/dist/types/signals";
+ * @import { SignalOptions } from "./0.4.11/dist/types/core/core"
+ * @import { getOwner as GetOwner, onCleanup as OnCleanup } from "./0.4.11/dist/types/core/owner"
+ * @import { createSignal as CreateSignal, createEffect as CreateEffect, createMemo as CreateMemo, createRoot as CreateRoot, runWithOwner as RunWithOwner, Setter } from "./0.4.11/dist/types/signals";
  */
 
 /**
@@ -16,6 +16,8 @@
  * @typedef {Accessor<T> & { set: Setter<T>; reset: VoidFunction }} Signal
  */
 
+console.log("bob");
+
 import {
   createSignal,
   createEffect,
@@ -24,7 +26,7 @@ import {
   createRoot,
   runWithOwner,
   onCleanup,
-} from "./0.4.1/dist/prod.js";
+} from "./0.4.11/dist/prod.js";
 
 let effectCount = 0;
 

websites/packages/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "strict": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "outDir": "/tmp/brk",
+    "lib": ["DOM", "DOM.Iterable", "ESNext", "WebWorker"],
+    "skipLibCheck": true
+  },
+  "exclude": ["scripts/packages", "scripts/bridge"]
+}