remove is() again

Author: estherbrunner

README.md

@@ -16,7 +16,7 @@ In the `connectedCallback()` you setup references to inner elements, add event l
 
 `UIElement` is fast. In fact, faster than any JavaScript framework. Only direct fine-grained DOM updates in vanilla JavaScript can beat its performance. But then, you have no loose coupling of components and need to parse attributes and track changes yourself. This tends to get tedious and messy rather quickly. `UIElement` provides a structured way to keep your components simple, consistent and self-contained.
 
-`UIElement` is tiny. 890 bytes gzipped over the wire. And it has zero dependiences. If you want to understand how it works, you have to study the source code of [one single file](./index.js).
+`UIElement` is tiny. 889 bytes gzipped over the wire. And it has zero dependiences. If you want to understand how it works, you have to study the source code of [one single file](./index.js).
 
 That's all.
 
@@ -246,7 +246,7 @@ It consists of three functions:
 - `derive()` returns a getter function for the current value of the derived computation
 - `effect()` accepts a callback function to be exectuted when used signals change
 
-Cause & Effect is possibly the simplest way to turn JavaScript into a reactive language – with just 400 bytes gezipped code. By default, Cause & Effect doesn't do any memoization for derived signals but recalculates their current values each time. Contrary to general expectations, this seems to be faster in most cases. If you however are performing expensive work in computed signals or rely on the count of execution times, you should turn memoization on, by setting the second parameter of `derive()` to `true`.
+Cause & Effect is possibly the simplest way to turn JavaScript into a reactive language – with just 386 bytes gezipped code. By default, Cause & Effect doesn't do any memoization for derived signals but recalculates their current values each time. Contrary to general expectations, this seems to be faster in most cases. If you however are performing expensive work in computed signals or rely on the count of execution times, you should turn memoization on, by setting the second parameter of `derive()` to `true`.
 
 #### Usage Example
 

cause-effect.js

@@ -12,21 +12,13 @@ const autorun = (effects) => {
         effect.run();
 };
 /* === Exported functions === */
-/**
- * Check if a given variable is a given JavaScript primitive type
- *
- * @param {string} type - JavaScript primitive type to check against
- * @param {unknown} value - variable to check if it is of the given JavaScript primitive type
- * @returns {boolean} true if supplied parameter is of the given JavaScript primitive type
- */
-const is = (type, value) => typeof value === type;
 /**
  * Check if a given variable is a function
  *
  * @param {unknown} fn - variable to check if it is a function
  * @returns {boolean} true if supplied parameter is a function
  */
-const isFunction = (fn) => is('function', fn);
+const isFunction = (fn) => typeof fn === 'function';
 /**
  * Check if a given variable is a reactive state
  *
@@ -112,4 +104,4 @@ const effect = (fn) => {
     next();
 };
 
-export { cause, derive, effect, is, isFunction, isState };
+export { cause, derive, effect, isFunction, isState };

cause-effect.min.js

@@ -12,21 +12,13 @@ const autorun = (effects) => {
         effect.run();
 };
 /* === Exported functions === */
-/**
- * Check if a given variable is a given JavaScript primitive type
- *
- * @param {string} type - JavaScript primitive type to check against
- * @param {unknown} value - variable to check if it is of the given JavaScript primitive type
- * @returns {boolean} true if supplied parameter is of the given JavaScript primitive type
- */
-const is = (type, value) => typeof value === type;
 /**
  * Check if a given variable is a function
  *
  * @param {unknown} fn - variable to check if it is a function
  * @returns {boolean} true if supplied parameter is a function
  */
-const isFunction = (fn) => is('function', fn);
+const isFunction = (fn) => typeof fn === 'function';
 /**
  * Check if a given variable is a reactive state
  *
@@ -125,7 +117,7 @@ class ContextRequestEvent extends Event {
  * @param {unknown} value - value to check if it is a string
  * @returns {boolean} true if supplied parameter is a string
  */
-const isString = (value) => is('string', value);
+const isString = (value) => typeof value === 'string';
 /* === Default export === */
 /**
  * Base class for reactive custom elements
@@ -301,7 +293,7 @@ const isStylable = (node) => {
  * @param {unknown} value - variable to check if it is defined
  * @returns {boolean} true if supplied parameter is defined
  */
-const isDefined = (value) => !is('undefined', value) && value !== null;
+const isDefined = (value) => typeof value !== 'undefined' && value !== null;
 /**
  * Wrapper around a native DOM element for DOM manipulation
  *
@@ -454,7 +446,7 @@ const asJSON = (value) => {
  * @param {unknown} value - value to check if it is an object
  * @returns {boolean} true if supplied parameter is an object
  */
-const isObject = (value) => isDefined(value) && is('object', value);
+const isObject = (value) => isDefined(value) && typeof value === 'object';
 /* === Default export === */
 /**
  * Create a UIElement subclass for a custom element tag

component.js

@@ -12,21 +12,13 @@ const autorun = (effects) => {
         effect.run();
 };
 /* === Exported functions === */
-/**
- * Check if a given variable is a given JavaScript primitive type
- *
- * @param {string} type - JavaScript primitive type to check against
- * @param {unknown} value - variable to check if it is of the given JavaScript primitive type
- * @returns {boolean} true if supplied parameter is of the given JavaScript primitive type
- */
-const is = (type, value) => typeof value === type;
 /**
  * Check if a given variable is a function
  *
  * @param {unknown} fn - variable to check if it is a function
  * @returns {boolean} true if supplied parameter is a function
  */
-const isFunction = (fn) => is('function', fn);
+const isFunction = (fn) => typeof fn === 'function';
 /**
  * Check if a given variable is a reactive state
  *

component.min.js

@@ -15,14 +15,6 @@ interface UIState<T> {
 type UIDOMInstructionQueue = (element: Element, fn: () => void) => void;
 type UIMaybeCleanup = void | (() => void);
 type UIEffectCallback = (enqueue: UIDOMInstructionQueue) => UIMaybeCleanup;
-/**
- * Check if a given variable is a given JavaScript primitive type
- *
- * @param {string} type - JavaScript primitive type to check against
- * @param {unknown} value - variable to check if it is of the given JavaScript primitive type
- * @returns {boolean} true if supplied parameter is of the given JavaScript primitive type
- */
-declare const is: (type: string, value: unknown) => boolean;
 /**
  * Check if a given variable is a function
  *
@@ -61,4 +53,4 @@ declare const derive: <T>(fn: () => T, memo?: boolean) => UIComputed<T>;
  * @param {UIEffectCallback} fn - callback function to be executed when a state changes
  */
 declare const effect: (fn: UIEffectCallback) => void;
-export { type UIState, type UIComputed, type UIEffect, type UIDOMInstructionQueue, is, isFunction, isState, cause, derive, effect };
+export { type UIState, type UIComputed, type UIEffect, type UIDOMInstructionQueue, isFunction, isState, cause, derive, effect };