@mouseless/baked 0.19.0

package/dist/runtime/components/SideMenuItem.vue.d.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof __VLS_props>;
+    item: Record<string, any>;
+    path: string;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_props: {
+    readonly item: Record<string, any>;
+    readonly path: string;
+};

package/dist/runtime/components/Text.d.vue.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof __VLS_props>;
+    schema: any;
+    data: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_props: {
+    readonly schema: any;
+    readonly data: any;
+};

package/dist/runtime/components/Text.vue

@@ -0,0 +1,36 @@
+<template>
+  <Skeleton
+    v-if="loading"
+    height="1.5rem"
+  />
+  <span
+    v-else-if="data"
+    v-tooltip.bottom="tooltip"
+  >{{ text }}</span>
+  <span v-else>-</span>
+</template>
+
+<script setup>
+import { computed } from "vue";
+import { Skeleton } from "primevue";
+import { useContext, useFormat } from "#imports";
+const context = useContext();
+const { truncate } = useFormat();
+const { schema, data } = defineProps({
+  schema: { type: null, required: true },
+  data: { type: null, required: true }
+});
+const { maxLength } = schema;
+const loading = context.injectLoading();
+const lengthIsExceeded = computed(() => maxLength && data.length > maxLength);
+const text = computed(() => lengthIsExceeded.value ? truncate(data, maxLength) : data);
+const tooltip = computed(() => ({
+  value: `${data}`,
+  disabled: !lengthIsExceeded.value,
+  pt: {
+    root: {
+      style: maxLength ? `min-width: ${maxLength / 4}rem;` : ""
+    }
+  }
+}));
+</script>

package/dist/runtime/components/Text.vue.d.ts

@@ -0,0 +1,11 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {
+    $props: Partial<typeof __VLS_props>;
+    schema: any;
+    data: any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_props: {
+    readonly schema: any;
+    readonly data: any;
+};

package/dist/runtime/composables/useBreakpoints.d.ts

@@ -0,0 +1 @@
+export default function _default(): {};

package/dist/runtime/composables/useBreakpoints.js

@@ -0,0 +1,48 @@
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import { useRuntimeConfig } from "#app";
+
+export default function() {
+  const { public: { composables: { useBreakpoints: { screens } } } } = useRuntimeConfig();
+
+  const sizes = Object
+    .keys(screens)
+    .reduce((result, key) => ({ [key]: removePx(screens[key]), ...result }), {});
+
+  const refs = {};
+  Object.keys(sizes).forEach(key => {
+    refs[`is${capitalize(key)}`] = ref(false);
+    refs[`isMax${capitalize(key)}`] = ref(false);
+  });
+
+  const update = () => {
+    const width = globalThis.innerWidth;
+
+    Object.keys(sizes).forEach(key => {
+      refs[`is${capitalize(key)}`].value = width >= sizes[key];
+      refs[`isMax${capitalize(key)}`].value = width < sizes[key];
+    });
+  };
+
+  onMounted(() => {
+    update();
+    globalThis.addEventListener("resize", update);
+  });
+
+  onBeforeUnmount(() => {
+    globalThis.removeEventListener("resize", update);
+  });
+
+  function removePx(size) {
+    return typeof size === "string"
+      ? parseInt(size.replace("px", ""), 10)
+      : size;
+  }
+
+  function capitalize(str) {
+    if(str.length === 0) { return str; }
+
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  return refs;
+}

package/dist/runtime/composables/useCache.d.ts

@@ -0,0 +1,13 @@
+export default function _default(name: any, { expirationInMinutes }?: {
+    expirationInMinutes?: number | undefined;
+}): {
+    buildKey: ({ path, query }: {
+        path: any;
+        query: any;
+    }) => any;
+    getOrCreate: ({ key, create }: {
+        key: any;
+        create: any;
+    }) => Promise<any>;
+    clear: () => void;
+};

package/dist/runtime/composables/useCache.js

@@ -0,0 +1,60 @@
+export default function(name, { expirationInMinutes = 60 } = {}) {
+  function buildKey({ path, query }) {
+    let result = path;
+    if(query) {
+      const search = new URLSearchParams(query);
+      search.sort();
+      result += `?${search}`;
+    }
+
+    return result;
+  }
+
+  function isCacheValid(entry) {
+    return Date.now() - entry.createdAt < expirationInMinutes * 60 * 1000;
+  }
+
+  async function getOrCreate({ key, create }) {
+    if(typeof create !== "function") {
+      throw new Error("create must be a function");
+    }
+
+    key = `${name}[${key}]`;
+
+    const cached = localStorage.getItem(key);
+    if(cached) {
+      const entry = JSON.parse(cached);
+      if(isCacheValid(entry)) {
+        return entry.data;
+      }
+    }
+
+    const result = await create();
+    localStorage.setItem(key, JSON.stringify({
+      createdAt: Date.now(),
+      data: result
+    }));
+
+    return result;
+  }
+
+  function clear() {
+    const keysToClear = [];
+    for(let i = 0; i<localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if(key.startsWith(name)) {
+        keysToClear.push(key);
+      }
+    }
+
+    for(const key of keysToClear) {
+      localStorage.removeItem(key);
+    }
+  }
+
+  return {
+    buildKey,
+    getOrCreate,
+    clear
+  };
+}

package/dist/runtime/composables/useComponentResolver.d.ts

@@ -0,0 +1,3 @@
+export default function _default(): {
+    resolve: (type: any, fallback: any) => any;
+};

package/dist/runtime/composables/useComponentResolver.js

@@ -0,0 +1,13 @@
+import * as components from "@@/.baked/components";
+
+export default function() {
+  function resolve(type, fallback) {
+    return components[type]
+      ? components[type]
+      : components[fallback];
+  }
+
+  return {
+    resolve
+  };
+}

package/dist/runtime/composables/useComposableResolver.d.ts

@@ -0,0 +1,3 @@
+export default function _default(): {
+    resolve: (name: any) => any;
+};

package/dist/runtime/composables/useComposableResolver.js

@@ -0,0 +1,15 @@
+import { useNuxtApp } from "#app";
+
+export default function() {
+  const { $composables } = useNuxtApp();
+
+  function resolve(name) {
+    if(!$composables[name]) { throw new Error(`Cannot resolve composable '${name}'`); }
+
+    return $composables[name]();
+  }
+
+  return {
+    resolve
+  };
+}

package/dist/runtime/composables/useConditional.d.ts

@@ -0,0 +1,3 @@
+export default function _default(): {
+    find: (conditional: any, data: any) => any;
+};

package/dist/runtime/composables/useConditional.js

@@ -0,0 +1,15 @@
+export default function() {
+
+  function find(conditional, data) {
+    const conditions = conditional.conditions.filter(component => data[component.prop] === component.value);
+    if(conditions.length > 0) {
+      return conditions[0].component;
+    }
+
+    return conditional.fallback;
+  }
+
+  return {
+    find
+  };
+}

package/dist/runtime/composables/useContext.d.ts

@@ -0,0 +1,15 @@
+export default function _default(): {
+    injectPath: () => string;
+    providePath: (name: any) => void;
+    injectDataDescriptor: () => null;
+    provideDataDescriptor: (value: any) => void;
+    injectData: () => {
+        ParentData: null;
+        Custom: null;
+    };
+    provideData: (value: any, key: any) => void;
+    injectLoading: () => import("vue").Ref<boolean, boolean>;
+    provideLoading: (value: any) => void;
+    injectPage: () => any;
+    providePage: (value: any) => void;
+};

package/dist/runtime/composables/useContext.js

@@ -0,0 +1,60 @@
+import { inject, provide, ref } from "vue";
+
+export default function() {
+  function providePath(name) {
+    const path = inject("__bake_path", null);
+    provide("__bake_path", path ? `${path}/${name}` : name);
+  }
+
+  function injectPath() {
+    return inject("__bake_path", "");
+  }
+
+  function injectDataDescriptor() {
+    return inject("__bake_data_descriptor", null);
+  }
+
+  function provideDataDescriptor(value) {
+    return provide("__bake_data_descriptor", value);
+  }
+
+  function injectData() {
+    return {
+      ParentData: inject("__bake_injected_data:ParentData", null),
+      Custom: inject("__bake_injected_data:Custom", null)
+    };
+  }
+
+  function provideData(value, key) {
+    provide(`__bake_injected_data:${key}`, value);
+  }
+
+  function injectLoading() {
+    return inject("__bake_loading", ref(false));
+  }
+
+  function provideLoading(value) {
+    provide("__bake_loading", value);
+  }
+
+  function injectPage() {
+    return inject("__bake_page");
+  }
+
+  function providePage(value) {
+    provide("__bake_page", value);
+  }
+
+  return {
+    injectPath,
+    providePath,
+    injectDataDescriptor,
+    provideDataDescriptor,
+    injectData,
+    provideData,
+    injectLoading,
+    provideLoading,
+    injectPage,
+    providePage
+  };
+}

package/dist/runtime/composables/useDataFetcher.d.ts

@@ -0,0 +1,15 @@
+export default function _default(): {
+    shouldLoad: (dataType: any) => boolean;
+    get: ({ data, injectedData }: {
+        data: any;
+        injectedData: any;
+    }) => any;
+    fetch: ({ data, injectedData }: {
+        data: any;
+        injectedData: any;
+    }) => Promise<any>;
+    fetchParameters: ({ data, injectedData }: {
+        data: any;
+        injectedData: any;
+    }) => Promise<any>;
+};

package/dist/runtime/composables/useDataFetcher.js

@@ -0,0 +1,203 @@
+import { useRuntimeConfig } from "#app";
+import { useComposableResolver, useUnref } from "#imports";
+
+export default function() {
+  const datas = {
+    "Composite": Composite({ parentFetch: fetch, parentFetchParameters: fetchParameters }),
+    "Computed": Computed(),
+    "Injected": Injected(),
+    "Inline": Inline(),
+    "Remote": Remote({ parentFetch: fetch })
+  };
+
+  function shouldLoad(dataType) {
+    return datas[dataType]?.fetch !== undefined;
+  }
+
+  function get({ data, injectedData }) {
+    const type = data?.type;
+    if(!type) { return null; }
+    if(!datas[type]) { return null; }
+    if(!datas[type].get) { return null; }
+
+    return datas[type].get({ data, injectedData });
+  }
+
+  async function fetch({ data, injectedData }) {
+    const fetcher = datas[data?.type];
+    if(!fetcher) { throw new Error(`${data?.type} is not a valid data type`); }
+
+    return fetcher.get
+      ? fetcher.get({ data, injectedData })
+      : await fetcher.fetch({ data, injectedData });
+  }
+
+  async function fetchParameters({ data, injectedData }) {
+    const fetcher = datas[data?.type];
+
+    return fetcher?.fetchParameters
+      ? fetcher.fetchParameters({ data, injectedData })
+      : [];
+  }
+
+  return {
+    shouldLoad,
+    get,
+    fetch,
+    fetchParameters
+  };
+}
+
+function Composite({ parentFetch, parentFetchParameters }) {
+  const unref = useUnref();
+
+  async function fetch({ data, injectedData }) {
+    const result = {};
+
+    for(const part of data.parts) {
+      Object.assign(
+        result,
+        unref.deepUnref(await parentFetch({ data: part, injectedData }))
+      );
+    }
+
+    return result;
+  }
+
+  async function fetchParameters({ data, injectedData }) {
+    const result = [];
+
+    for(const part of data.parts) {
+      result.push(
+        ...unref.deepUnref(await parentFetchParameters({ data: part, injectedData }))
+      );
+    }
+
+    return result;
+  }
+
+  return {
+    fetch,
+    fetchParameters
+  };
+}
+
+function Computed() {
+  const composableResolver = useComposableResolver();
+
+  async function fetch({ data }) {
+    const composable = (await composableResolver.resolve(data.composable)).default();
+
+    if(composable.compute) {
+      return composable.compute(...(data.args || []));
+    }
+
+    if(composable.computeAsync) {
+      return await composable.computeAsync(...(data.args || []));
+    }
+
+    throw new Error("Data composable should have either `compute` or `computeAsync`");
+  }
+
+  function fetchParameters({ data }) {
+    return data.args;
+  }
+
+  return {
+    fetch,
+    fetchParameters
+  };
+}
+
+function Injected() {
+  function get({ data, injectedData }) {
+    const result = injectedData[data.key];
+
+    if(!data.prop) { return result; }
+
+    return result.value?.[data.prop];
+  }
+
+  return {
+    get
+  };
+}
+
+function Inline() {
+  function get({ data }) {
+    return data.value;
+  }
+
+  return {
+    get
+  };
+}
+
+function Remote({ parentFetch }) {
+  const { public: { composables } } = useRuntimeConfig();
+  const unref = useUnref();
+
+  async function fetch({ data, injectedData }) {
+    const baseURL = composables.useDataFetcher.baseURL;
+    const headers = await fetchHeaders({ data, injectedData });
+    const query = await fetchQuery({ data, injectedData });
+
+    const options = { baseURL, headers: headers, query: query };
+    if(data.attributes) {
+      options.attributes = data.attributes;
+    }
+    const retry = composables?.useDataFetcher?.retry ?? false;
+
+    if(retry) {
+      return await fetchWithRetry(data.path, options, retry);
+    }
+
+    return await $fetch(data.path, { ...options, retry: false });
+  }
+
+  async function fetchHeaders({ data, injectedData }) {
+    return data.headers
+      ? unref.deepUnref(await parentFetch({ data: data.headers, injectedData }))
+      : { };
+  }
+
+  async function fetchQuery({ data, injectedData }) {
+    return data.query
+      ? unref.deepUnref(await parentFetch({ data: data.query, injectedData }))
+      : { };
+  }
+
+  async function fetchParameters(options) {
+    return Object.values(await fetchQuery(options));
+  }
+
+  async function fetchWithRetry(url, options,
+    { maxRetry = Number.MAX_VALUE, delay = 200 } = { }
+  ) {
+    let lastError = null;
+    for(let i = -1; i < maxRetry; i++) { // i starts at -1 to allow for the first attempt
+      try {
+        return await $fetch(url, { ...options, retry: false });
+      } catch (error) {
+        lastError = error;
+
+        if(error.response) { // server is up and returned and error
+          break;
+        }
+
+        await wait(delay);
+      }
+    }
+
+    throw lastError;
+  }
+
+  function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  return {
+    fetch,
+    fetchParameters
+  };
+}

package/dist/runtime/composables/useFormat.d.ts

@@ -0,0 +1,16 @@
+export default function _default(): {
+    asClasses: (path: any, prefix?: string) => any;
+    asCurrency: (value: any, { shorten, shortenThousands }?: {}) => "-" | {
+        shortened: boolean;
+        toString: () => string;
+    };
+    asDecimal: (value: any) => any;
+    asMonth: (date: any) => any;
+    asNumber: (value: any, { shorten, shortenThousands, formatOptions }?: {}) => "-" | {
+        shortened: boolean;
+        toString: () => string;
+    };
+    asPercentage: (value: any) => any;
+    format: (formatString: any, args: any) => any;
+    truncate: (value: any, length: any) => any;
+};

package/dist/runtime/composables/useFormat.js

@@ -0,0 +1,116 @@
+import { useRuntimeConfig } from "#app";
+import { useLocalization } from "#imports";
+
+export default function() {
+  const { locale: currentLocale, localize: lc } = useLocalization({ group: "useFormat" });
+  const { public: { composables } } = useRuntimeConfig();
+
+  const locale = currentLocale.value || "en";
+  const currency = composables?.useFormat?.currency || "USD";
+  const B = lc("suffix.B"); // billions
+  const M = lc("suffix.M"); // millions
+  const K = lc("suffix.K"); // thousands
+
+  const STAGES = [
+    { threshold: 1_000_000_000, divisor: 1_000_000_000, suffix: B, fraction: true },
+    { threshold: 1_000_000, divisor: 1_000_000, suffix: M, fraction: true },
+    { threshold: 1_000, divisor: 1_000, suffix: K, fraction: true },
+    { threshold: 999.9999, divisor: 1, suffix: "", fraction: false },
+    { threshold: Number.MIN_VALUE, divisor: 1, suffix: "", fraction: true }
+  ];
+
+  function asClasses(path,
+    prefix = "b--"
+  ) {
+    return path.split("/")
+      .filter(item => item.length > 0)
+      .map(item => `${prefix}${item}`);
+  }
+
+  function asCurrency(value,
+    { shorten, shortenThousands } = { }
+  ) {
+    return asNumber(value, {
+      shorten,
+      shortenThousands,
+      formatOptions: {
+        style: "currency",
+        currency
+      }
+    }) ;
+  }
+
+  function asDecimal(value) {
+    value ||= "-";
+
+    return value.toLocaleString(locale, { style: "decimal", maximumFractionDigits: 2 });
+  }
+
+  function asMonth(date) {
+    return date.toLocaleString(locale, { month: "long" });
+  }
+
+  function asNumber(value,
+    { shorten, shortenThousands, formatOptions } = { }
+  ) {
+    if(!value) { return "-"; }
+
+    shorten ??= true;
+    shortenThousands ??= false;
+    formatOptions ??= { };
+
+    const stage = shorten
+      ? STAGES.find(s => (shortenThousands || s.threshold !== 1_000) && Math.abs(value) >= s.threshold) ?? STAGES[STAGES.length - 1]
+      : STAGES[STAGES.length - 1];
+    const shownValue = value / stage.divisor;
+
+    const fractionDigitCount = stage.fraction ? 2 : 0;
+    const formattedResult = shownValue.toLocaleString(locale, {
+      maximumFractionDigits: fractionDigitCount,
+      trailingZeroDisplay: "stripIfInteger",
+      ...formatOptions
+    });
+
+    return {
+      shortened: stage.suffix !== "",
+      toString: () => formattedResult + stage.suffix
+    };
+  }
+
+  function asPercentage(value) {
+    value ||= "-";
+
+    return value.toLocaleString(locale, { style: "percent", maximumFractionDigits: 2 });
+  }
+
+  function format(formatString, args) {
+    // TODO: this format call is temporary, final design should handle path
+    // variables using name, not index, e.g., /test/{0} -> /test/{id}
+    return formatString.replace(/(\{\{\d\}\}|\{\d\})/g, part => {
+      if(part.substring(0, 2) === "{{") { return part; } // escape
+
+      const index = parseInt(part.match(/\d/)[0]);
+
+      return args[index];
+    });
+  }
+
+  function truncate(value, length) {
+    if(!value || !length || value.length <= length - 3) {
+      return value;
+    }
+
+    return value.substring(0, length - 3).concat("...");
+  }
+
+  return {
+    asClasses,
+    asCurrency,
+    asDecimal,
+    asMonth,
+    asNumber,
+    asPercentage,
+    format,
+    truncate
+  };
+};