proto-daisy-ui 0.0.2

package/dist/components/store.js

@@ -0,0 +1,329 @@
+import { getRenderingRef, forceUpdate } from '@stencil/core/internal/client';
+
+const KEY = 'proto-daisy-ui';
+const LOGIN = 'login';
+const MFE = 'mfe';
+const PICK = 'pick';
+const THEME = 'theme';
+// Examples:
+//   get(MFE)
+//   get(PICK)
+//
+const bag = {
+  get: (tag) => {
+    const key = tag ? `${KEY}-${tag}` : KEY;
+    const json = localStorage.getItem(key);
+    return json ? JSON.parse(json) : undefined;
+  },
+  store: (tag, value) => {
+    const key = tag ? `${KEY}-${tag}` : KEY;
+    const json = JSON.stringify(value === undefined ? null : value);
+    localStorage.setItem(key, json);
+  },
+};
+
+const appendToMap = (map, propName, value) => {
+    const items = map.get(propName);
+    if (!items) {
+        map.set(propName, [value]);
+    }
+    else if (!items.includes(value)) {
+        items.push(value);
+    }
+};
+const debounce = (fn, ms) => {
+    let timeoutId;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = 0;
+            fn(...args);
+        }, ms);
+    };
+};
+
+/**
+ * Check if a possible element isConnected.
+ * The property might not be there, so we check for it.
+ *
+ * We want it to return true if isConnected is not a property,
+ * otherwise we would remove these elements and would not update.
+ *
+ * Better leak in Edge than to be useless.
+ */
+const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
+const cleanupElements = debounce((map) => {
+    for (let key of map.keys()) {
+        map.set(key, map.get(key).filter(isConnected));
+    }
+}, 2000);
+const stencilSubscription = () => {
+    if (typeof getRenderingRef !== 'function') {
+        // If we are not in a stencil project, we do nothing.
+        // This function is not really exported by @stencil/core.
+        return {};
+    }
+    const elmsToUpdate = new Map();
+    return {
+        dispose: () => elmsToUpdate.clear(),
+        get: (propName) => {
+            const elm = getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        },
+        set: (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        },
+        reset: () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(forceUpdate));
+            cleanupElements(elmsToUpdate);
+        },
+    };
+};
+
+const unwrap = (val) => (typeof val === 'function' ? val() : val);
+const createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
+    const unwrappedState = unwrap(defaultState);
+    let states = new Map(Object.entries(unwrappedState !== null && unwrappedState !== void 0 ? unwrappedState : {}));
+    const handlers = {
+        dispose: [],
+        get: [],
+        set: [],
+        reset: [],
+    };
+    const reset = () => {
+        var _a;
+        // When resetting the state, the default state may be a function - unwrap it to invoke it.
+        // otherwise, the state won't be properly reset
+        states = new Map(Object.entries((_a = unwrap(defaultState)) !== null && _a !== void 0 ? _a : {}));
+        handlers.reset.forEach((cb) => cb());
+    };
+    const dispose = () => {
+        // Call first dispose as resetting the state would
+        // cause less updates ;)
+        handlers.dispose.forEach((cb) => cb());
+        reset();
+    };
+    const get = (propName) => {
+        handlers.get.forEach((cb) => cb(propName));
+        return states.get(propName);
+    };
+    const set = (propName, value) => {
+        const oldValue = states.get(propName);
+        if (shouldUpdate(value, oldValue, propName)) {
+            states.set(propName, value);
+            handlers.set.forEach((cb) => cb(propName, value, oldValue));
+        }
+    };
+    const state = (typeof Proxy === 'undefined'
+        ? {}
+        : new Proxy(unwrappedState, {
+            get(_, propName) {
+                return get(propName);
+            },
+            ownKeys(_) {
+                return Array.from(states.keys());
+            },
+            getOwnPropertyDescriptor() {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            has(_, propName) {
+                return states.has(propName);
+            },
+            set(_, propName, value) {
+                set(propName, value);
+                return true;
+            },
+        }));
+    const on = (eventName, callback) => {
+        handlers[eventName].push(callback);
+        return () => {
+            removeFromArray(handlers[eventName], callback);
+        };
+    };
+    const onChange = (propName, cb) => {
+        const unSet = on('set', (key, newValue) => {
+            if (key === propName) {
+                cb(newValue);
+            }
+        });
+        // We need to unwrap the defaultState because it might be a function.
+        // Otherwise we might not be sending the right reset value.
+        const unReset = on('reset', () => cb(unwrap(defaultState)[propName]));
+        return () => {
+            unSet();
+            unReset();
+        };
+    };
+    const use = (...subscriptions) => {
+        const unsubs = subscriptions.reduce((unsubs, subscription) => {
+            if (subscription.set) {
+                unsubs.push(on('set', subscription.set));
+            }
+            if (subscription.get) {
+                unsubs.push(on('get', subscription.get));
+            }
+            if (subscription.reset) {
+                unsubs.push(on('reset', subscription.reset));
+            }
+            if (subscription.dispose) {
+                unsubs.push(on('dispose', subscription.dispose));
+            }
+            return unsubs;
+        }, []);
+        return () => unsubs.forEach((unsub) => unsub());
+    };
+    const forceUpdate = (key) => {
+        const oldValue = states.get(key);
+        handlers.set.forEach((cb) => cb(key, oldValue, oldValue));
+    };
+    return {
+        state,
+        get,
+        set,
+        on,
+        onChange,
+        use,
+        dispose,
+        reset,
+        forceUpdate,
+    };
+};
+const removeFromArray = (array, item) => {
+    const index = array.indexOf(item);
+    if (index >= 0) {
+        array[index] = array[array.length - 1];
+        array.length--;
+    }
+};
+
+const createStore = (defaultState, shouldUpdate) => {
+    const map = createObservableMap(defaultState, shouldUpdate);
+    map.use(stencilSubscription());
+    return map;
+};
+
+function mitt(n){return {all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e]);},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]));},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e);}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e);});}}}
+
+const themes = [
+  'light',
+  'dark',
+  'aqua',
+  'business',
+  'corporate',
+  'fantasy',
+  'night',
+  'winter',
+  'wireframe',
+];
+// --------------------------------------------------------[ mutable store ]
+const storeDef = {
+  login: true,
+  mfe: 'proto-home',
+  pick: 0,
+  theme: 'dark',
+  themes,
+};
+const { state } = createStore(storeDef);
+const emitter = mitt();
+// --------------------------------------------------------[ utility ]
+const clearStore = (login = false) => {
+  state.login = login;
+  state.pick = 0;
+  state.mfe = 'proto-home';
+  state.theme = 'dark';
+  state.themes = themes;
+};
+// --------------------------------------------------------[ processing ]
+const processApp = (next) => {
+  state.mfe = next;
+  if (next) {
+    bag.store(LOGIN, false);
+    state.login = false;
+    emitter.emit('app', { mfe: next });
+  }
+  else {
+    bag.store(LOGIN, true);
+    state.login = true;
+  }
+};
+const processLogin = (next) => {
+  state.login = next;
+  if (next) {
+    emitter.emit('login', { login: next });
+  }
+};
+const processPick = (next) => {
+  state.pick = next;
+  if (next) {
+    emitter.emit('pick', { pick: next });
+  }
+};
+const processTheme = (next) => {
+  state.theme = next;
+  console.log(next);
+  if (next) {
+    emitter.emit('theme', { theme: next });
+  }
+};
+// --------------------------------------------------------[ actions ]
+const initApp = () => {
+  clearStore();
+  // this retrieves the last data we stored in the bag...
+  const login = bag.get(LOGIN);
+  const data = bag.get(MFE);
+  const pick = bag.get(PICK);
+  const theme = bag.get(THEME);
+  console.log('-- data:', data);
+  if (theme) {
+    processTheme(theme);
+    if (login !== undefined) {
+      processLogin(login);
+    }
+    if (login === false && data) {
+      console.log('-- app:', data);
+      processApp(data);
+    }
+    if (pick) {
+      processPick(pick);
+    }
+  }
+  else {
+    refresh();
+  }
+};
+const refresh = () => {
+  clearStore(true);
+  bag.store(PICK, 0);
+};
+const updateApp = (mfe) => {
+  bag.store(MFE, mfe);
+  processApp(mfe);
+};
+const updatePick = (pick) => {
+  bag.store(PICK, pick);
+  processPick(pick);
+};
+const updateTheme = (theme) => {
+  bag.store(THEME, theme);
+  processTheme(theme);
+};
+const actions = {
+  initApp,
+  refresh,
+  updateApp,
+  updatePick,
+  updateTheme,
+};
+
+export { actions as a, state as s };

package/dist/esm/dealers-752f9914.js

@@ -0,0 +1,13 @@
+const dealers = [
+  { id: 'brookhaven', name: 'Brookhaven' },
+  { id: 'buckhead', name: 'Buckhead' },
+  { id: 'dawsonville', name: 'Dawsonville' },
+  { id: 'decatur', name: 'Decatur' },
+  { id: 'kennesaw', name: 'Kennesaw' },
+  { id: 'marietta', name: 'Marietta' },
+  { id: 'peachtree', name: 'Peachtree' },
+  { id: 'perimeter', name: 'Perimeter' },
+  { id: 'stoneMountain', name: 'Stone Mountain' },
+];
+
+export { dealers as d };