riftt 1.0.0 → 1.0.1

package/src/sprae/directive/value.js

@@ -1,100 +0,0 @@
-import sprae, { parse } from "../core.js";
-import { dir } from "../core.js";
-import { setter } from "../store.js";
-import { attr } from "./default.js";
-
-dir("value", (el, state, expr) => {
-  const type = el.type || "";
-  const tag = el.tagName;
-
-  const setText = (value) => {
-    const v = value ?? "";
-    el.value = v;
-    el.setAttribute("value", v);
-  };
-
-  const textUpdate = (value) => setText(value);
-
-  const textareaUpdate = (value) => {
-    const from = el.selectionStart;
-    const to = el.selectionEnd;
-    setText(value);
-    if (from) el.setSelectionRange(from, to);
-  };
-
-  const checkboxUpdate = (value) => {
-    el.checked = value;
-    attr(el, "checked", value);
-  };
-
-  const radioUpdate = (value) => {
-    if (el.value === value) {
-      el.checked = value;
-      attr(el, "checked", value);
-    }
-  };
-
-  const selectOneUpdate = (value) => {
-    for (const o of el.options) {
-      if (o.value == value) o.setAttribute("selected", "");
-      else o.removeAttribute("selected");
-    }
-    el.value = value;
-  };
-
-  const selectMultipleUpdate = (value) => {
-    for (const o of el.options) o.removeAttribute("selected");
-    for (const v of value) el.querySelector(`[value="${v}"]`)?.setAttribute("selected", "");
-  };
-
-  const defaultUpdate = (value) => {
-    el.value = value;
-  };
-
-  const pickUpdater = () => {
-    if (tag === "TEXTAREA") return textareaUpdate;
-    switch (type) {
-      case "text":
-      case "":
-        return textUpdate;
-      case "checkbox":
-        return checkboxUpdate;
-      case "radio":
-        return radioUpdate;
-      case "select-one":
-        return selectOneUpdate;
-      case "select-multiple":
-        return selectMultipleUpdate;
-      default:
-        return defaultUpdate;
-    }
-  };
-
-  const update = pickUpdater();
-
-  try {
-    const set = setter(expr);
-
-    const handleChange =
-      type === "checkbox"
-        ? () => set(state, el.checked)
-        : type === "select-multiple"
-          ? () =>
-              set(
-                state,
-                [...el.selectedOptions].map((o) => o.value),
-              )
-          : () => set(state, el.selectedIndex < 0 ? null : el.value);
-
-    el.oninput = el.onchange = handleChange;
-
-    if (type?.startsWith("select")) {
-      new MutationObserver(handleChange).observe(el, { childList: true, subtree: true, attributes: true });
-      sprae(el, state);
-    }
-
-    parse(expr)(state) ?? handleChange();
-  } catch {}
-
-  return update;
-});

package/src/sprae/directive/with.js

@@ -1,20 +0,0 @@
-import sprae, { dir } from "../core.js";
-import { untracked } from "../signal.js";
-import store from "../store.js";
-
-dir("with", (el, rootState) => {
-  let local;
-
-  return (values) => {
-    if (!local) {
-      // force untracked to avoid accidental subscriptions during setup
-      untracked(() => {
-        local = store(values, rootState);
-        sprae(el, local);
-      });
-      return;
-    }
-
-    sprae(el, values);
-  };
-});

package/src/sprae/persist.js

@@ -1,214 +0,0 @@
-import { effect } from "./signal.js";
-import { _signals, _change } from "./store.js";
-
-/**
- * symbol for accessing persistence configuration on a store
- * @type {symbol}
- */
-export const _persist = Symbol("persist");
-
-/**
- * persistence configuration options
- * @typedef {Object} PersistOptions
- * @property {string} [key] - localStorage key (defaults to store name or auto-generated)
- * @property {Storage} [storage=localStorage] - storage interface (localStorage, sessionStorage, or custom)
- * @property {string[]} [paths] - specific paths to persist (defaults to all)
- * @property {number} [debounce=300] - debounce delay in milliseconds for writes
- * @property {function} [serializer] - custom serializer for complex types
- * @property {function} [deserializer] - custom deserializer for complex types
- */
-
-/**
- * default serializer that handles common types
- * @param {any} value - value to serialize
- * @returns {string} serialized value
- */
-const defaultSerializer = (value) => {
-  try {
-    return JSON.stringify(value, (key, val) => {
-      if (typeof val === "function") return undefined;
-      if (val && typeof val === "object" && val.constructor !== Object && !Array.isArray(val)) {
-        return undefined;
-      }
-      return val;
-    });
-  } catch {
-    return "{}";
-  }
-};
-
-/**
- * default deserializer
- * @param {string} value - serialized value
- * @returns {any} deserialized value
- */
-const defaultDeserializer = (value) => {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return {};
-  }
-};
-
-/**
- * creates a debounced function that delays execution
- * @param {function} fn - function to debounce
- * @param {number} delay - delay in milliseconds
- * @returns {function} debounced function
- */
-const debounce = (fn, delay) => {
-  let timeoutId;
-  return (...args) => {
-    clearTimeout(timeoutId);
-    timeoutId = setTimeout(() => fn(...args), delay);
-  };
-};
-
-/**
- * extracts values from store at specified paths
- * @param {Object} store - the store proxy
- * @param {string[]} paths - paths to extract
- * @returns {Object} extracted values
- */
-const extractPaths = (store, paths) => {
-  const result = {};
-
-  if (!paths) {
-    const signals = store[_signals];
-    for (const key in signals) {
-      const signal = signals[key];
-      if (signal && !signal._set && key[0] !== "_") {
-        result[key] = store[key];
-      }
-    }
-  } else {
-    for (const path of paths) {
-      if (path in store) {
-        result[path] = store[path];
-      }
-    }
-  }
-
-  return result;
-};
-
-/**
- * checks if storage is available
- * @param {Storage} storage - storage to test
- * @returns {boolean} whether storage is available
- */
-const isStorageAvailable = (storage) => {
-  try {
-    const testKey = "__storage_test__";
-    storage.setItem(testKey, "test");
-    storage.removeItem(testKey);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-/**
- * creates persistence functionality for a store
- * @param {Object} store - the store proxy
- * @param {string} storeKey - unique key for the store
- * @param {PersistOptions} options - persistence configuration
- * @returns {function} cleanup function to stop persistence
- */
-export const createPersistence = (store, storeKey, options = {}) => {
-  const config = {
-    key: storeKey,
-    storage: globalThis.localStorage,
-    paths: null,
-    debounce: 0,
-    serializer: defaultSerializer,
-    deserializer: defaultDeserializer,
-    ...options,
-  };
-
-  if (!isStorageAvailable(config.storage)) {
-    console.warn(`persistence: ${config.storage === globalThis.localStorage ? "localStorage" : "storage"} is not available`);
-    return () => {};
-  }
-
-  let isHydrating = false;
-
-  /**
-   * saves current store state to storage
-   */
-  const saveState = debounce(() => {
-    if (isHydrating) return;
-
-    try {
-      const state = extractPaths(store, config.paths);
-      const serialized = config.serializer(state);
-      config.storage.setItem(config.key, serialized);
-    } catch (error) {
-      console.warn("persistence: failed to save state", error);
-    }
-  }, config.debounce);
-
-  /**
-   * restores state from storage
-   */
-  const restoreState = () => {
-    try {
-      const stored = config.storage.getItem(config.key);
-      if (!stored) return;
-
-      const state = config.deserializer(stored);
-      if (!state || typeof state !== "object") return;
-
-      isHydrating = true;
-
-      for (const key in state) {
-        if (key in store[_signals] && !store[_signals][key]?._set) {
-          store[key] = state[key];
-        }
-      }
-
-      isHydrating = false;
-    } catch (error) {
-      console.warn("persistence: failed to restore state", error);
-      isHydrating = false;
-    }
-  };
-
-  restoreState();
-
-  const cleanup = effect(() => {
-    if (config.paths) {
-      for (const path of config.paths) {
-        store[path];
-      }
-    } else {
-      const signals = store[_signals];
-      for (const key in signals) {
-        const signal = signals[key];
-        if (signal && !signal._set && key[0] !== "_") {
-          store[key];
-        }
-      }
-    }
-    saveState();
-  });
-
-  store[_persist] = { config, saveState, restoreState };
-
-  return cleanup;
-};
-
-/**
- * applies persistence to a store
- * @param {Object} store - the store to persist
- * @param {string} key - unique key for persistence
- * @param {PersistOptions|boolean} options - persistence options or true for defaults
- * @returns {function} cleanup function
- */
-export const persist = (store, key, options = {}) => {
-  if (options === true) {
-    options = {};
-  }
-
-  return createPersistence(store, key, options);
-};

package/src/sprae/signal.js

@@ -1,106 +0,0 @@
-let current;
-
-export let signal = (initialValue) => {
-  let value = initialValue;
-  const observers = new Set();
-
-  const signalObject = {
-    get value() {
-      if (current) {
-        current.deps.push(observers.add(current));
-      }
-      return value;
-    },
-
-    set value(newValue) {
-      if (newValue === value) return;
-      value = newValue;
-      for (const subscriber of observers) {
-        subscriber();
-      }
-    },
-
-    peek() {
-      return value;
-    },
-  };
-
-  signalObject.toJSON = () => signalObject.value;
-  signalObject.then = () => signalObject.value;
-  signalObject.toString = () => signalObject.value;
-  signalObject.valueOf = () => signalObject.value;
-
-  return signalObject;
-};
-
-export let effect = (effectFunction) => {
-  let teardownFunction;
-  let previousCurrent;
-
-  const effectExecutor = () => {
-    if (teardownFunction) {
-      teardownFunction.call();
-    }
-
-    previousCurrent = current;
-    current = effectExecutor;
-
-    try {
-      teardownFunction = effectFunction();
-    } finally {
-      current = previousCurrent;
-    }
-  };
-
-  effectExecutor.deps = [];
-  effectExecutor();
-
-  return () => {
-    if (teardownFunction) {
-      teardownFunction.call();
-    }
-
-    let dependency;
-    while ((dependency = effectExecutor.deps.pop())) {
-      dependency.delete(effectExecutor);
-    }
-  };
-};
-
-export let computed = (computeFunction) => {
-  const internalSignal = signal();
-  let effectCleanup;
-
-  const computedObject = {
-    get value() {
-      if (!effectCleanup) {
-        effectCleanup = effect(() => {
-          internalSignal.value = computeFunction();
-        });
-      }
-      return internalSignal.value;
-    },
-
-    peek: internalSignal.peek,
-  };
-
-  computedObject.toJSON = () => computedObject.value;
-  computedObject.then = () => computedObject.value;
-  computedObject.toString = () => computedObject.value;
-  computedObject.valueOf = () => computedObject.value;
-
-  return computedObject;
-};
-
-export let batch = (fn) => fn();
-
-export let untracked = batch;
-
-// signals adapter - allows switching signals implementation and not depend on core
-export let use = (impl) => {
-  signal = impl.signal;
-  effect = impl.effect;
-  computed = impl.computed;
-  batch = impl.batch || batch;
-  untracked = impl.untracked || untracked;
-};

package/src/sprae/sprae.js

@@ -1,20 +0,0 @@
-import sprae from "./core.js";
-
-// default directives
-import "./directive/if.js";
-import "./directive/each.js";
-import "./directive/ref.js";
-import "./directive/with.js";
-import "./directive/text.js";
-import "./directive/class.js";
-import "./directive/style.js";
-import "./directive/value.js";
-import "./directive/fx.js";
-import "./directive/default.js";
-import "./directive/aria.js";
-import "./directive/data.js";
-
-// default compiler (indirect new Function to avoid detector)
-sprae.use({ compile: (expr) => sprae.constructor(`with (arguments[0]) { return ${expr} };`) });
-
-export default sprae;

package/src/sprae/store.js

@@ -1,197 +0,0 @@
-// signals-based proxy
-import { signal, computed, batch } from "./signal.js";
-import { parse } from "./core.js";
-
-export const _signals = Symbol("signals");
-export const _change = Symbol("change");
-export const _stash = "__";
-
-// length changing methods
-const mutatingMethods = ["push", "pop", "shift", "unshift", "splice"];
-
-// set/update signal value
-const set = (signals, key, value) => {
-  const existingSignal = signals[key];
-  const currentValue = existingSignal?.peek();
-
-  if (key[0] === "_") {
-    signals[key] = value;
-    return;
-  }
-
-  if (!existingSignal) {
-    signals[key] = value?.peek ? value : signal(store(value));
-    return;
-  }
-
-  if (value === currentValue) {
-    return;
-  }
-
-  if (existingSignal._set) {
-    existingSignal._set(value);
-    return;
-  }
-
-  if (Array.isArray(value) && Array.isArray(currentValue)) {
-    if (currentValue[_change]) {
-      batch(() => {
-        for (let i = 0; i < value.length; i++) {
-          currentValue[i] = value[i];
-        }
-        currentValue.length = value.length;
-      });
-    } else {
-      existingSignal.value = value;
-    }
-    return;
-  }
-
-  existingSignal.value = store(value);
-};
-
-// object store is not lazy
-export const store = (values, parent) => {
-  if (!values) {
-    return values;
-  }
-
-  if (values[_signals] || values[Symbol.toStringTag]) {
-    return values;
-  }
-
-  if (values.constructor !== Object) {
-    return Array.isArray(values) ? list(values) : values;
-  }
-
-  const signals = Object.create(parent?.[_signals] || {});
-  const lengthSignal = signal(Object.keys(values).length);
-  let stash;
-
-  const state = new Proxy(signals, {
-    get(target, key) {
-      if (key === _change) return lengthSignal;
-      if (key === _signals) return signals;
-      if (key === _stash) return stash;
-      if (key in signals) return signals[key]?.valueOf();
-      return globalThis[key];
-    },
-
-    set(target, key, value) {
-      if (key === _stash) {
-        stash = value;
-        return true;
-      }
-
-      const existed = key in signals;
-      set(signals, key, value);
-      if (!existed) {
-        lengthSignal.value++;
-      }
-      return true;
-    },
-
-    deleteProperty(target, key) {
-      const signalToDelete = signals[key];
-      if (signalToDelete) {
-        signalToDelete[Symbol.dispose]?.();
-        delete signals[key];
-        lengthSignal.value--;
-      }
-      return true;
-    },
-
-    ownKeys(target) {
-      lengthSignal.value;
-      return Reflect.ownKeys(signals);
-    },
-
-    has(target, key) {
-      return true;
-    },
-  });
-
-  const descriptors = Object.getOwnPropertyDescriptors(values);
-
-  for (const key in values) {
-    const descriptor = descriptors[key];
-
-    if (descriptor?.get) {
-      const computedSignal = computed(descriptor.get.bind(state));
-      computedSignal._set = descriptor.set?.bind(state);
-      signals[key] = computedSignal;
-    } else {
-      signals[key] = null;
-      set(signals, key, values[key]);
-    }
-  }
-
-  return state;
-};
-
-// array store - signals are lazy since arrays can be very large & expensive
-export const list = (values) => {
-  let lastAccessedProperty;
-  const lengthSignal = signal(values.length);
-  const signals = Array(values.length).fill();
-
-  const state = new Proxy(signals, {
-    get(target, key) {
-      if (typeof key === "symbol") {
-        if (key === _change) return lengthSignal;
-        if (key === _signals) return signals;
-        return signals[key];
-      }
-
-      if (key === "length") {
-        return mutatingMethods.includes(lastAccessedProperty) ? lengthSignal.peek() : lengthSignal.value;
-      }
-
-      lastAccessedProperty = key;
-
-      if (!signals[key]) {
-        signals[key] = signal(store(values[key]));
-      }
-
-      return signals[key].valueOf();
-    },
-
-    set(target, key, value) {
-      if (key === "length") {
-        for (let i = value; i < signals.length; i++) {
-          delete state[i];
-        }
-        lengthSignal.value = signals.length = value;
-        return true;
-      }
-
-      set(signals, key, value);
-
-      if (key >= lengthSignal.peek()) {
-        lengthSignal.value = signals.length = +key + 1;
-      }
-
-      return true;
-    },
-
-    deleteProperty(target, key) {
-      signals[key]?.[Symbol.dispose]?.();
-      delete signals[key];
-      return true;
-    },
-  });
-
-  return state;
-};
-
-// create expression setter, reflecting value back to state
-export const setter = (expression) => {
-  const fn = parse(`${expression}=${_stash}`);
-
-  return (state, value) => {
-    state[_stash] = value;
-    fn(state);
-  };
-};
-
-export default store;