valyrian.js 7.2.11 → 8.0.0

package/lib/proxy-signal/index.ts

@@ -1,187 +0,0 @@
-import { update } from "valyrian.js";
-
-/* eslint-disable no-use-before-define */
-interface Cleanup {
-  (): void;
-}
-
-interface Subscription {
-  // eslint-disable-next-line no-unused-vars
-  (value: ProxySignal["value"]): void | Cleanup;
-}
-
-interface Subscriptions extends Map<Subscription, Cleanup> {}
-
-interface Getter {
-  // eslint-disable-next-line no-unused-vars
-  (value: ProxySignal["value"]): any;
-}
-
-interface Getters {
-  [key: string | symbol]: Getter;
-}
-
-interface ProxySignal {
-  // Works as a getter of the value
-  (): ProxySignal["value"];
-  // Works as a subscription to the value
-  // eslint-disable-next-line no-unused-vars
-  (value: Subscription): ProxySignal;
-  // Works as a setter with a path and a handler
-  // eslint-disable-next-line no-unused-vars
-  (path: string, handler: (valueAtPathPosition: any) => any): ProxySignal["value"];
-  // Works as a setter with a path and a value
-  // eslint-disable-next-line no-unused-vars
-  (path: string, value: any): ProxySignal["value"];
-  // Works as a setter with a value
-  // eslint-disable-next-line no-unused-vars
-  (value: any): ProxySignal["value"];
-  // Gets the current value of the signal.
-  value: any;
-  // Cleanup function to be called to remove all subscriptions.
-  cleanup: () => void;
-  // Creates a getter on the signal.
-  // eslint-disable-next-line no-unused-vars
-  getter: (name: string, handler: Getter) => any;
-  // To access the getters on the signal.
-  [key: string | number | symbol]: any;
-}
-
-function makeUnsubscribe(
-  subscriptions: Subscriptions,
-  computed: ProxySignal,
-  handler: Subscription,
-  cleanup?: Cleanup
-) {
-  if (typeof cleanup === "function") {
-    computed.cleanup = cleanup;
-  }
-  computed.unsubscribe = () => {
-    subscriptions.delete(handler);
-    computed?.cleanup();
-  };
-}
-
-function createSubscription(signal: ProxySignal, subscriptions: Subscriptions, handler: Subscription) {
-  if (subscriptions.has(handler) === false) {
-    // eslint-disable-next-line no-use-before-define
-    let computed = ProxySignal(() => handler(signal.value));
-    let cleanup = computed(); // Execute to register itself
-    makeUnsubscribe(subscriptions, computed, handler, cleanup);
-    subscriptions.set(handler, computed);
-  }
-
-  return subscriptions.get(handler);
-}
-
-let updateTimeout: any;
-function delayedUpdate() {
-  clearTimeout(updateTimeout);
-  updateTimeout = setTimeout(update);
-}
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function ProxySignal(value: any): ProxySignal {
-  let subscriptions = new Map();
-  let getters: Getters = {};
-
-  let forceUpdate = false;
-
-  let signal: ProxySignal = new Proxy(
-    // eslint-disable-next-line no-unused-vars
-    function (valOrPath?: any | Subscription, handler?: (valueAtPathPosition: any) => any) {
-      // Works as a getter
-      if (typeof valOrPath === "undefined") {
-        return signal.value;
-      }
-
-      // Works as a subscription
-      if (typeof valOrPath === "function") {
-        return createSubscription(signal, subscriptions, valOrPath);
-      }
-
-      // Works as a setter with a path
-      if (typeof valOrPath === "string" && typeof handler !== "undefined") {
-        let parsed = valOrPath.split(".");
-        let result = signal.value;
-        let next;
-        while (parsed.length) {
-          next = parsed.shift() as string;
-          if (parsed.length > 0) {
-            if (typeof result[next] !== "object") {
-              result[next] = {};
-            }
-            result = result[next];
-          } else {
-            result[next] = typeof handler === "function" ? handler(result[next]) : handler;
-          }
-        }
-        forceUpdate = true;
-        signal.value = signal.value;
-        return signal.value;
-      }
-
-      // Works as a setter with a value
-      signal.value = valOrPath;
-      return signal.value;
-    } as ProxySignal,
-    {
-      set(state, prop, val) {
-        if (prop === "value" || prop === "unsubscribe" || prop === "cleanup") {
-          let old = state[prop];
-          state[prop] = val;
-          if (prop === "value" && (forceUpdate || val !== old)) {
-            forceUpdate = false;
-            for (let [handler, computed] of subscriptions) {
-              computed.cleanup();
-              let cleanup = handler(val);
-              makeUnsubscribe(subscriptions, computed, handler, cleanup);
-            }
-            delayedUpdate();
-          }
-          return true;
-        }
-        return false;
-      },
-      get(state, prop) {
-        if (prop === "value") {
-          return typeof state.value === "function" ? state.value() : state.value;
-        }
-
-        if (prop === "cleanup" || prop === "unsubscribe" || prop === "getter") {
-          return state[prop];
-        }
-
-        if (prop in getters) {
-          return getters[prop](state.value);
-        }
-      }
-    }
-  );
-
-  Object.defineProperties(signal, {
-    value: { value, writable: true, enumerable: true },
-    cleanup: {
-      value() {
-        // eslint-disable-next-line no-unused-vars
-        for (let [handler, computed] of subscriptions) {
-          computed.unsubscribe();
-        }
-      },
-      writable: true,
-      enumerable: true
-    },
-    getter: {
-      value(name: string, handler: Getter) {
-        if (name in getters) {
-          throw new Error("Named computed already exists.");
-        }
-
-        getters[name] = handler;
-      },
-      enumerable: true
-    }
-  });
-
-  return signal;
-}

package/lib/signal/index.ts

@@ -1,161 +0,0 @@
-import { VnodeWithDom, current, onUnmount, updateVnode, v } from "valyrian.js";
-
-interface GetterInterface {
-  (): any;
-}
-
-interface SetterInterface {
-  (value: any): void;
-}
-
-interface SubscribeInterface {
-  (callback: Function): void;
-}
-
-interface SubscriptionsInterface extends Array<Function> {}
-
-export interface SignalInterface extends Array<any> {
-  0: GetterInterface;
-  1: SetterInterface;
-  2: SubscribeInterface;
-  3: SubscriptionsInterface;
-}
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function Signal(initialValue: any): SignalInterface {
-  // Create a copy of the current context object
-  const { vnode, component } = { ...current };
-
-  // Check if the context object has a vnode property
-  if (vnode && component) {
-    // Is first call
-    if (!vnode.components) {
-      // Set the components property to an empty array
-      vnode.components = [];
-    }
-
-    // Check if the components array of the vnode object does not contain the component object
-    if (vnode.components.indexOf(component) === -1) {
-      // Set the calls property to -1
-      vnode.signal_calls = -1;
-      // Add the component to the components array
-      vnode.components.push(component);
-
-      // Check if the component object has a signals property
-      if (!component.signals) {
-        // Set the signals property of the component object to an empty array
-        component.signals = [];
-        // Add a function to the cleanup stack that removes the signals property from the component object
-        onUnmount(() => Reflect.deleteProperty(component, "signals"));
-      }
-    }
-
-    // Assign the signal variable to the signal stored at the index of the vnode object's calls property in the vnode's signals array
-    let signal: SignalInterface = component.signals[++vnode.signal_calls];
-
-    // If a signal has already been assigned to the signal variable, return it
-    if (signal) {
-      // Remove all subscriptions because we come from a new render
-      signal[3].length = 0;
-
-      // Return the signal
-      return signal;
-    }
-  }
-
-  // Declare a variable to store the current value of the Signal
-  let value = initialValue;
-
-  // Create an array to store functions that have subscribed to changes to the Signal's value
-  const subscriptions: SubscriptionsInterface = [];
-
-  // Define a function that allows other parts of the code to subscribe to changes to the Signal's value
-  const subscribe = (callback: Function) => {
-    // Add the callback function to the subscriptions array if it is not already in the array
-    if (subscriptions.indexOf(callback) === -1) {
-      subscriptions.push(callback);
-    }
-  };
-
-  // Set the vnodes to update when the Signal's value changes
-  let vnodesToUpdate: Array<VnodeWithDom> = [];
-
-  // This is the function that will be called when the Signal's value changes
-  const updateVnodes = () => {
-    // Create a copy of the vnodesToUpdate array and filter out any duplicate vnodes
-    let vnodesToUpdateCopy = vnodesToUpdate.filter((vnode, index, self) => {
-      return self.findIndex((v) => v.dom === vnode.dom) === index;
-    });
-
-    // Loop through the vnodesToUpdate array
-    for (let i = 0, l = vnodesToUpdateCopy.length; i < l; i++) {
-      const vnode2 = vnodesToUpdateCopy[i];
-      // If it does, create a new vnode object based on the original vnode, its children, and its DOM and SVG properties
-      let newVnode = v(vnode2.tag, vnode2.props, ...vnode2.initialChildren) as VnodeWithDom;
-      newVnode.dom = vnode2.dom; // Set the new vnode object's DOM property to the old vnode object's DOM property
-      newVnode.isSVG = vnode2.isSVG; // Set the new vnode object's isSVG property to the old vnode object's isSVG property
-
-      // Update the vnode object
-      updateVnode(newVnode, vnode2);
-    }
-  };
-
-  // Define a function that returns the current value of the Signal
-  function get() {
-    // Get the current vnode from the context object
-    const { vnode: vnode2 } = current;
-
-    // If we have a current vnode, it means that a get function is being called from within a component
-    // so we subscribe the vnode to be updated when the Signal's value changes
-    if (vnode2 && vnodesToUpdate.indexOf(vnode2) === -1) {
-      // We set the initialChildren to a copy of the vnode's children array
-      // This is the case when the vnode is a component that has not been rendered yet and we need the initial children
-      // because they could have the components that are using the Signal
-      if (!vnode2.initialChildren) {
-        vnode2.initialChildren = [...vnode2.children];
-      }
-
-      // Add the vnode to the vnodesToUpdate array
-      vnodesToUpdate.push(vnode2);
-
-      // Subscribe the updateVnodes function to the Signal
-      subscribe(updateVnodes);
-    }
-
-    // Return the current value of the Signal
-    return value;
-  }
-
-  // Define a function that allows the value of the Signal to be updated and notifies any subscribed functions of the change
-  const set = (newValue: any) => {
-    // If we have a current event on going, prevent the default action
-    if (current.event) {
-      current.event.preventDefault();
-    }
-
-    // Just return if the new value is the same as the current value
-    if (newValue === value) {
-      return;
-    }
-
-    // Update the value of the Signal
-    value = newValue;
-
-    // Call each subscribed function with the new value of the Signal as an argument
-    for (let i = 0, l = subscriptions.length; i < l; i++) {
-      subscriptions[i](value);
-    }
-  };
-
-  // Assign the signal variable an array containing the get, set, and subscribe functions
-  let signal: SignalInterface = [get, set, subscribe, subscriptions];
-
-  // If the context object has a vnode property, add the signal to the vnode's signals array
-  // and add the subscriptions array to the vnode's subscriptions array
-  if (vnode && component) {
-    component.signals.push(signal);
-  }
-
-  // Return the signal
-  return signal;
-}

package/lib/store/index.ts

@@ -1,101 +0,0 @@
-import { update } from "valyrian.js";
-
-interface StoreOptions {
-  state?: Record<string, unknown> | (() => Record<string, unknown>);
-  getters?: Record<string, Function>;
-  mutations?: Record<string, Function>;
-  actions?: Record<string, Function>;
-}
-
-interface StoreInstance {
-  // eslint-disable-next-line no-unused-vars
-  new (options: StoreOptions): StoreInstance;
-  state: Record<string, any>;
-  getters?: Record<string, any>;
-  // eslint-disable-next-line no-unused-vars
-  commit: (type: string, ...payload: any[]) => void;
-  // eslint-disable-next-line no-unused-vars
-  dispatch: (type: string, ...payload: any[]) => void;
-}
-
-function keyExists(typeOfKey: string, object: Record<string, unknown>, key: string) {
-  if (key in object === false) {
-    throw new Error(`The ${typeOfKey} "${key}" does not exists.`);
-  }
-}
-
-function deepFreeze(obj: any) {
-  if (typeof obj === "object" && obj !== null && !Object.isFrozen(obj)) {
-    if (Array.isArray(obj)) {
-      for (let i = 0, l = obj.length; i < l; i++) {
-        deepFreeze(obj[i]);
-      }
-    } else {
-      let props = Reflect.ownKeys(obj);
-      for (let i = 0, l = props.length; i < l; i++) {
-        deepFreeze(obj[props[i]]);
-      }
-    }
-    Object.freeze(obj);
-  }
-
-  return obj;
-}
-
-let updateTimeout: any;
-function delayedUpdate() {
-  clearTimeout(updateTimeout);
-  updateTimeout = setTimeout(update);
-}
-
-export const Store = function Store(
-  this: StoreInstance,
-  { state = {}, getters = {}, actions = {}, mutations = {} }: StoreOptions = {}
-) {
-  let frozen = true;
-
-  function isUnfrozen() {
-    if (frozen) {
-      throw new Error("You need to commit a mutation to change the state");
-    }
-  }
-
-  let localState = typeof state === "function" ? state() : state;
-
-  this.state = new Proxy(localState || {}, {
-    get: (state, prop: string) => deepFreeze(state[prop]),
-    set: (state, prop: string, value: any) => {
-      isUnfrozen();
-      state[prop] = value;
-      return true;
-    },
-    deleteProperty: (state, prop: string) => {
-      isUnfrozen();
-      Reflect.deleteProperty(state, prop);
-      return true;
-    }
-  });
-
-  this.getters = new Proxy(getters, {
-    get: (getters, getter: string) => {
-      try {
-        return getters[getter](this.state, this.getters);
-      } catch (e) {
-        // Getters should fail silently
-      }
-    }
-  });
-
-  this.commit = (mutation, ...args) => {
-    keyExists("mutation", mutations, mutation);
-    frozen = false;
-    mutations[mutation](this.state, ...args);
-    frozen = true;
-    delayedUpdate();
-  };
-
-  this.dispatch = (action, ...args) => {
-    keyExists("action", actions, action);
-    return Promise.resolve(actions[action](this, ...args));
-  };
-} as unknown as StoreInstance;