proto-sudoku-wc 0.0.689 → 0.0.691

package/dist/collection/utils/store.js

@@ -3,279 +3,279 @@ import ky from "ky";
 import { bag } from "./bag";
 // --------------------------------------------------------[ mutable store ]
 const storeDef = {
-  list: [],
-  keys: [],
-  locs: [],
-  loading: false,
-  solved: false,
-  error: undefined,
-  pick: undefined,
-  data: undefined,
+    list: [],
+    keys: [],
+    locs: [],
+    loading: false,
+    solved: false,
+    error: undefined,
+    pick: undefined,
+    data: undefined,
 };
 const { state } = createStore(storeDef);
 // --------------------------------------------------------[ geometry ]
 // NOTE:  by using Sets here, we don't have to worry about clearing geometry...
 const geometry = new Map([
-  ['row', new Map()],
-  ['column', new Map()],
-  ['box', new Map()],
+    ['row', new Map()],
+    ['column', new Map()],
+    ['box', new Map()],
 ]);
 const keyValues = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
 const computeBox = (row, column) => {
-  if (column < 3) {
-    return row < 3 ? 0 : row < 6 ? 3 : 6;
-  }
-  else {
-    if (column < 6) {
-      return row < 3 ? 1 : row < 6 ? 4 : 7;
+    if (column < 3) {
+        return row < 3 ? 0 : row < 6 ? 3 : 6;
     }
     else {
-      return row < 3 ? 2 : row < 6 ? 5 : 8;
+        if (column < 6) {
+            return row < 3 ? 1 : row < 6 ? 4 : 7;
+        }
+        else {
+            return row < 3 ? 2 : row < 6 ? 5 : 8;
+        }
     }
-  }
 };
 const computeLocs = (index, row, column, box) => {
-  const data = new Map([
-    ['row', row],
-    ['column', column],
-    ['box', box],
-  ]);
-  const locs = new Set();
-  data.forEach((value, key) => {
-    geometry
-      .get(key)
-      .get(value)
-      .forEach(indx => {
-      indx !== index && locs.add(indx);
+    const data = new Map([
+        ['row', row],
+        ['column', column],
+        ['box', box],
+    ]);
+    const locs = new Set();
+    data.forEach((value, key) => {
+        geometry
+            .get(key)
+            .get(value)
+            .forEach(indx => {
+            indx !== index && locs.add(indx);
+        });
     });
-  });
-  return Array.from(locs);
+    return Array.from(locs);
 };
 const computeKeys = locs => {
-  const { list } = state;
-  const found = new Set();
-  locs.map(indx => {
-    const { key } = list[indx];
-    if (key != '.') {
-      found.add(key);
-    }
-  });
-  const keys = keyValues.filter(key => !found.has(key));
-  return keys;
+    const { list } = state;
+    const found = new Set();
+    locs.map(indx => {
+        const { key } = list[indx];
+        if (key != '.') {
+            found.add(key);
+        }
+    });
+    const keys = keyValues.filter(key => !found.has(key));
+    return keys;
 };
 const updateGeometry = (index, row, column, box) => {
-  const data = new Map([
-    ['row', row],
-    ['column', column],
-    ['box', box],
-  ]);
-  data.forEach((value, key) => {
-    const map = geometry.get(key);
-    if (map.has(value)) {
-      // looking at the set specification, it should be sufficient to just call add
-      // https://tc39.es/ecma262/#sec-set.prototype.add
-      map.get(value).add(index);
-    }
-    else {
-      map.set(value, new Set([index]));
-    }
-  });
+    const data = new Map([
+        ['row', row],
+        ['column', column],
+        ['box', box],
+    ]);
+    data.forEach((value, key) => {
+        const map = geometry.get(key);
+        if (map.has(value)) {
+            // looking at the set specification, it should be sufficient to just call add
+            // https://tc39.es/ecma262/#sec-set.prototype.add
+            map.get(value).add(index);
+        }
+        else {
+            map.set(value, new Set([index]));
+        }
+    });
 };
 const updateFromInputs = list => {
-  const inputs = bag.inputs.get();
-  inputs.forEach((key, indx) => {
-    const cell = list[indx];
-    const { isClue } = cell;
-    if (!isClue) {
-      cell.key = key;
-    }
-  });
+    const inputs = bag.inputs.get();
+    inputs.forEach((key, indx) => {
+        const cell = list[indx];
+        const { isClue } = cell;
+        if (!isClue) {
+            cell.key = key;
+        }
+    });
 };
 // --------------------------------------------------------[ process ]
 const processData = (next) => {
-  if (next) {
-    const { puzzle, ref } = next;
-    const cells = puzzle ? [...puzzle] : [];
-    const line = ref ? atob(ref) : undefined; // decrypt the solution... [ base64 ]
-    const solution = line ? [...line] : [];
-    const list = cells.map((key, indx) => {
-      const value = solution[indx];
-      const isClue = key === value;
-      const row = Math.floor(indx / 9);
-      const column = indx % 9;
-      const box = computeBox(row, column);
-      updateGeometry(indx, row, column, box);
-      return { key, isClue, value, indx, row, column, box };
-    });
-    // NOTE:  this only happens once on data change...
-    updateFromInputs(list);
-    state.data = next;
-    state.list = list;
-  }
-  else {
-    state.data = undefined;
-    state.list = [];
-  }
+    if (next) {
+        const { puzzle, ref } = next;
+        const cells = puzzle ? [...puzzle] : [];
+        const line = ref ? atob(ref) : undefined; // decrypt the solution... [ base64 ]
+        const solution = line ? [...line] : [];
+        const list = cells.map((key, indx) => {
+            const value = solution[indx];
+            const isClue = key === value;
+            const row = Math.floor(indx / 9);
+            const column = indx % 9;
+            const box = computeBox(row, column);
+            updateGeometry(indx, row, column, box);
+            return { key, isClue, value, indx, row, column, box };
+        });
+        // NOTE:  this only happens once on data change...
+        updateFromInputs(list);
+        state.data = next;
+        state.list = list;
+    }
+    else {
+        state.data = undefined;
+        state.list = [];
+    }
 };
 const processPick = (next) => {
-  if (next !== undefined && next.indx != state.pick) {
-    const { isClue, indx, row, column, box } = next;
-    const locs = computeLocs(indx, row, column, box);
-    const keys = isClue ? [] : computeKeys(locs);
-    state.pick = indx;
-    state.keys = keys;
-    state.locs = locs;
-    // NOTE:  we could auto-pick if there's only one key...
-    // (keys.length === 1) && next.key = keys[0];
-  }
-  else {
-    state.pick = undefined;
-    state.keys = [];
-    state.locs = [];
-  }
-  savePick(state.pick);
+    if (next !== undefined && next.indx != state.pick) {
+        const { isClue, indx, row, column, box } = next;
+        const locs = computeLocs(indx, row, column, box);
+        const keys = isClue ? [] : computeKeys(locs);
+        state.pick = indx;
+        state.keys = keys;
+        state.locs = locs;
+        // NOTE:  we could auto-pick if there's only one key...
+        // (keys.length === 1) && next.key = keys[0];
+    }
+    else {
+        state.pick = undefined;
+        state.keys = [];
+        state.locs = [];
+    }
+    savePick(state.pick);
 };
 // --------------------------------------------------------[ utils ]
 let api = undefined;
 const platformPrefix = {
-  netlify: '/.netlify/functions',
-  vercel: 'https://sudoku-rust-api.vercel.app/api',
+    netlify: '/.netlify/functions',
+    vercel: 'https://sudoku-rust-api.vercel.app/api',
 };
 const getPrefixFor = (platform) => {
-  const keys = Object.keys(platformPrefix);
-  const target = keys.includes(platform) ? platform : 'vercel';
-  return platformPrefix[target];
+    const keys = Object.keys(platformPrefix);
+    const target = keys.includes(platform) ? platform : 'vercel';
+    return platformPrefix[target];
 };
 const initApi = (platform) => {
-  const prefix = getPrefixFor(platform);
-  api = ky.extend({
-    hooks: {
-      beforeRequest: [
-        request => {
-          request.headers.set('X-Requested-With', 'ky');
-          request.headers.set('X-Custom-Header', 'foobar');
+    const prefix = getPrefixFor(platform);
+    api = ky.extend({
+        hooks: {
+            beforeRequest: [
+                request => {
+                    request.headers.set('X-Requested-With', 'ky');
+                    request.headers.set('X-Custom-Header', 'foobar');
+                },
+            ],
         },
-      ],
-    },
-    prefixUrl: prefix,
-    timeout: 10000,
-  });
+        prefixUrl: prefix,
+        timeout: 10000,
+    });
 };
 const saveInputs = (inputs) => {
-  bag.inputs.store(inputs);
+    bag.inputs.store(inputs);
 };
 const savePick = (pick) => {
-  bag.pick.store(pick);
+    bag.pick.store(pick);
 };
 const clearStore = (loading = false) => {
-  state.list = [];
-  state.keys = [];
-  state.locs = [];
-  state.loading = loading;
-  state.solved = false;
-  state.error = undefined;
-  state.pick = undefined;
-  state.data = undefined;
+    state.list = [];
+    state.keys = [];
+    state.locs = [];
+    state.loading = loading;
+    state.solved = false;
+    state.error = undefined;
+    state.pick = undefined;
+    state.data = undefined;
 };
 const updateStore = (data, save = true) => {
-  const { puzzle, ref } = data;
-  if (save) {
-    bag.inputs.store([]);
-    bag.store(data);
-  }
-  processData({ puzzle, ref });
+    const { puzzle, ref } = data;
+    if (save) {
+        bag.inputs.store([]);
+        bag.store(data);
+    }
+    processData({ puzzle, ref });
 };
 // --------------------------------------------------------[ actions ]
 const initApp = (platform) => {
-  initApi(platform);
-  clearStore();
-  // this retrieves the last data we stored in the bag...
-  const data = bag.get();
-  const pick = bag.pick.get();
-  if (data) {
-    updateStore(data, false);
-    if (pick >= 0) {
-      const { list } = state;
-      const cell = list[pick];
-      processPick(cell);
+    initApi(platform);
+    clearStore();
+    // this retrieves the last data we stored in the bag...
+    const data = bag.get();
+    const pick = bag.pick.get();
+    if (data) {
+        updateStore(data, false);
+        if (pick >= 0) {
+            const { list } = state;
+            const cell = list[pick];
+            processPick(cell);
+        }
     }
-  }
 };
 const refresh = async () => {
-  clearStore(true);
-  saveInputs([]);
-  savePick(state.pick);
-  try {
-    // fetch a new puzzle from the api...
-    const data = await api.get('puzzle').json();
-    updateStore(data);
-  }
-  catch (err) {
-    // handle error...
-    const { message } = err;
-    console.log('-- ', message);
-    console.log(err);
-    state.error = message;
-  }
-  finally {
-    // always executed
-    state.loading = false;
-  }
+    clearStore(true);
+    saveInputs([]);
+    savePick(state.pick);
+    try {
+        // fetch a new puzzle from the api...
+        const data = await api.get('puzzle').json();
+        updateStore(data);
+    }
+    catch (err) {
+        // handle error...
+        const { message } = err;
+        console.log('-- ', message);
+        console.log(err);
+        state.error = message;
+    }
+    finally {
+        // always executed
+        state.loading = false;
+    }
 };
 const select = (cell) => {
-  processPick(cell);
+    processPick(cell);
 };
 const redraw = (list) => {
-  state.list = [...list];
-  list.length = 0;
+    state.list = [...list];
+    list.length = 0;
 };
 const check = () => {
-  const { list } = state;
-  const inputs = [];
-  let errors = 0;
-  let found = 0;
-  let clues = 0;
-  list.forEach(cell => {
-    const { key, value, isClue } = cell;
-    if (!isClue) {
-      if (key !== '.') {
-        if (key !== value) {
-          errors = errors + 1;
-          cell.key = '.';
+    const { list } = state;
+    const inputs = [];
+    let errors = 0;
+    let found = 0;
+    let clues = 0;
+    list.forEach(cell => {
+        const { key, value, isClue } = cell;
+        if (!isClue) {
+            if (key !== '.') {
+                if (key !== value) {
+                    errors = errors + 1;
+                    cell.key = '.';
+                }
+                else {
+                    found = found + 1;
+                }
+            }
         }
         else {
-          found = found + 1;
+            clues = clues + 1;
         }
-      }
+        inputs.push(cell.key);
+    });
+    const total = clues + found;
+    found ? saveInputs(inputs) : saveInputs([]);
+    if (errors > 0) {
+        redraw(list);
     }
     else {
-      clues = clues + 1;
-    }
-    inputs.push(cell.key);
-  });
-  const total = clues + found;
-  found ? saveInputs(inputs) : saveInputs([]);
-  if (errors > 0) {
-    redraw(list);
-  }
-  else {
-    if (total === 81) {
-      state.solved = true;
+        if (total === 81) {
+            state.solved = true;
+        }
     }
-  }
 };
 const input = (key) => {
-  const { pick, list } = state;
-  const cell = list[pick];
-  cell.key = key;
-  redraw(list);
+    const { pick, list } = state;
+    const cell = list[pick];
+    cell.key = key;
+    redraw(list);
 };
 const actions = {
-  initApp,
-  refresh,
-  select,
-  check,
-  input,
+    initApp,
+    refresh,
+    select,
+    check,
+    input,
 };
 export { state, actions };
 export default state;

package/dist/collection/utils/tw.js

@@ -1,5 +1,5 @@
 const tw = (...classes) => {
-  return classes.filter(Boolean).join(' ');
+    return classes.filter(Boolean).join(' ');
 };
 export { tw };
 export default tw;

package/dist/esm/{index-3ccc3f4a.js → index-e105e4de.js}

@@ -446,7 +446,11 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
                         elm[memberName] = newValue;
                     }
                 }
-                catch (e) { }
+                catch (e) {
+                    /**
+                     * in case someone tries to set a read-only property, e.g. "namespaceURI", we just ignore it
+                     */
+                }
             }
             if (newValue == null || newValue === false) {
                 if (newValue !== false || elm.getAttribute(memberName) === '') {
@@ -465,6 +469,11 @@ const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {
     }
 };
 const parseClassListRegex = /\s/;
+/**
+ * Parsed a string of classnames into an array
+ * @param value className string, e.g. "foo bar baz"
+ * @returns list of classes, e.g. ["foo", "bar", "baz"]
+ */
 const parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex));
 const CAPTURE_EVENT_SUFFIX = 'Capture';
 const CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + '$');
@@ -1204,10 +1213,10 @@ const setValue = (ref, propName, newVal, cmpMeta) => {
  */
 const proxyComponent = (Cstr, cmpMeta, flags) => {
     var _a;
+    const prototype = Cstr.prototype;
     if (cmpMeta.$members$) {
         // It's better to have a const than two Object.entries()
         const members = Object.entries(cmpMeta.$members$);
-        const prototype = Cstr.prototype;
         members.map(([memberName, [memberFlags]]) => {
             if ((memberFlags & 31 /* MEMBER_FLAGS.Prop */ ||
                     ((flags & 2 /* PROXY_FLAGS.proxyState */) && memberFlags & 32 /* MEMBER_FLAGS.State */))) {
@@ -1230,6 +1239,7 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
             const attrNameToPropName = new Map();
             prototype.attributeChangedCallback = function (attrName, oldValue, newValue) {
                 plt.jmp(() => {
+                    var _a;
                     const propName = attrNameToPropName.get(attrName);
                     //  In a web component lifecycle the attributeChangedCallback runs prior to connectedCallback
                     //  in the case where an attribute was set inline.
@@ -1285,11 +1295,12 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                         // 1. The instance is ready
                         // 2. The watchers are ready
                         // 3. The value has changed
-                        if (!(flags & 8 /* HOST_FLAGS.isConstructingInstance */) &&
+                        if (flags &&
+                            !(flags & 8 /* HOST_FLAGS.isConstructingInstance */) &&
                             flags & 128 /* HOST_FLAGS.isWatchReady */ &&
                             newValue !== oldValue) {
                             const instance = hostRef.$lazyInstance$ ;
-                            const entry = cmpMeta.$watchers$[attrName];
+                            const entry = (_a = cmpMeta.$watchers$) === null || _a === void 0 ? void 0 : _a[attrName];
                             entry === null || entry === void 0 ? void 0 : entry.forEach((callbackName) => {
                                 if (instance[callbackName] != null) {
                                     instance[callbackName].call(instance, newValue, oldValue, attrName);

package/dist/esm/loader.js

@@ -1,5 +1,5 @@
-import { b as bootstrapLazy } from './index-3ccc3f4a.js';
-export { s as setNonce } from './index-3ccc3f4a.js';
+import { b as bootstrapLazy } from './index-e105e4de.js';
+export { s as setNonce } from './index-e105e4de.js';
 
 const defineCustomElements = (win, options) => {
   if (typeof window === 'undefined') return undefined;

package/dist/esm/proto-sudoku-wc.js

@@ -1,8 +1,8 @@
-import { p as promiseResolve, b as bootstrapLazy } from './index-3ccc3f4a.js';
-export { s as setNonce } from './index-3ccc3f4a.js';
+import { p as promiseResolve, b as bootstrapLazy } from './index-e105e4de.js';
+export { s as setNonce } from './index-e105e4de.js';
 
 /*
- Stencil Client Patch Browser v4.7.2 | MIT Licensed | https://stenciljs.com
+ Stencil Client Patch Browser v4.8.0 | MIT Licensed | https://stenciljs.com
  */
 const patchBrowser = () => {
     const importMeta = import.meta.url;