@shakerquiz/utilities 0.2.34 → 0.2.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shakerquiz/utilities",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "author": "yurkimus <yurkimus@gmail.com>",
   "license": "ISC",
   "exports": {

package/source/enumerations/features.js

@@ -77,61 +77,19 @@ export var FeatureKinds = {
 export var FeaturePathnames = /** @type {const} */ ({
   [Features.Checkin]: '/checkin',
   [Features.Cities]: '/cities',
-  [Features.City]: '/city/:city?',
-  [Features.Game]: '/game/:game?',
+  [Features.City]: `/city/:city?`,
+  [Features.Game]: `/game/:game?`,
   [Features.Games]: '/games',
-  [Features.Location]: '/location/:location?',
+  [Features.Location]: `/location/:location?`,
   [Features.Locations]: '/locations',
-  [Features.Registration]: '/registration/:registration?',
+  [Features.Registration]: `/registration/:registration?`,
   [Features.Registrations]: '/registrations',
-  [Features.Theme]: '/theme/:theme?',
+  [Features.Theme]: `/theme/:theme?`,
   [Features.Themes]: '/themes',
-  [Features.User]: '/user/:user?',
+  [Features.User]: `/user/:user?`,
   [Features.Users]: '/users',
 })
 
-export var FeaturePatterns = {
-  [Features.Checkin]: new URLPattern({
-    pathname: FeaturePathnames[Features.Checkin],
-  }),
-  [Features.Cities]: new URLPattern({
-    pathname: FeaturePathnames[Features.Cities],
-  }),
-  [Features.City]: new URLPattern({
-    pathname: FeaturePathnames[Features.City],
-  }),
-  [Features.Game]: new URLPattern({
-    pathname: FeaturePathnames[Features.Game],
-  }),
-  [Features.Games]: new URLPattern({
-    pathname: FeaturePathnames[Features.Games],
-  }),
-  [Features.Location]: new URLPattern({
-    pathname: FeaturePathnames[Features.Location],
-  }),
-  [Features.Locations]: new URLPattern({
-    pathname: FeaturePathnames[Features.Locations],
-  }),
-  [Features.Registration]: new URLPattern({
-    pathname: FeaturePathnames[Features.Registration],
-  }),
-  [Features.Registrations]: new URLPattern({
-    pathname: FeaturePathnames[Features.Registrations],
-  }),
-  [Features.Theme]: new URLPattern({
-    pathname: FeaturePathnames[Features.Theme],
-  }),
-  [Features.Themes]: new URLPattern({
-    pathname: FeaturePathnames[Features.Themes],
-  }),
-  [Features.User]: new URLPattern({
-    pathname: FeaturePathnames[Features.User],
-  }),
-  [Features.Users]: new URLPattern({
-    pathname: FeaturePathnames[Features.Users],
-  }),
-}
-
 export var FeatureMethodRequirements = {
   [Features.Checkin]: {
     [Methods.DELETE]: new Set([]),
@@ -345,3 +303,110 @@ export var FeatureNetworkOrigins = new Map([
     ]),
   ],
 ])
+
+export var FeatureNetworkUrls = new Map([
+  [
+    Features.Checkin,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Cities,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.City,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Game,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Games,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Location,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Locations,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Registration,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Registrations,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Theme,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Themes,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.User,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+  [
+    Features.Users,
+    new Map([
+      [Networks.Docker, null],
+      [Networks.Local, null],
+      [Networks.Public, null],
+    ]),
+  ],
+])

package/source/functions/fetch.js

@@ -2,12 +2,11 @@ import * as cookies from '@yurkimus/cookies'
 import { MessageError } from '@yurkimus/errors'
 import * as message from '@yurkimus/message'
 import { ResponseStatus } from '@yurkimus/response-status'
-import { url } from '@yurkimus/url'
 
 import { Cookies } from '../enumerations/cookies.js'
 import {
   FeatureKinds,
-  FeatureNetworkOrigins,
+  FeatureNetworkUrls,
   FeaturePathnames,
   Features,
 } from '../enumerations/features.js'
@@ -16,7 +15,20 @@ import { Methods } from '../enumerations/methods.js'
 import { Networks } from '../enumerations/networks.js'
 import { Roles } from '../enumerations/roles.js'
 
-let handleMessage = (feature, [response, body]) => {
+/**
+ * @typedef {'onbefore' | 'onfulfilled' | 'onrejected'} ExtensionHooks
+ */
+
+/**
+ * @typedef {WeakMap<Function, Map<ExtensionHooks, Set<Function>>>} Extensions
+ */
+
+/**
+ * @type {Extensions}
+ */
+export var extensions = new WeakMap()
+
+var handleMessage = (feature, [response, body]) => {
   switch (response.status) {
     case 200:
     case 201:
@@ -41,177 +53,103 @@ let handleMessage = (feature, [response, body]) => {
 
 /**
  * @template {keyof typeof Features} Feature
- * @template {keyof typeof Methods} Method
  * @template {keyof typeof Networks} Network
  *
  * @param {Feature} feature
- * @param {Method} method
  * @param {Network} network
- * @param {import('@yurkimus/url').URLOptions | undefined} options
- * @param {RequestInit} init
  */
-let request = (feature, method, network, options, init) => {
-  if (!('method' in init))
-    init.method = method
-
-  let instance = new Request(
-    url(
-      FeatureNetworkOrigins.get(feature).get(network),
-      FeaturePathnames[feature],
-      options,
-    ),
-    init,
-  )
-
-  if (!instance.headers.has('Content-Type'))
-    instance.headers.set(
-      'Content-Type',
-      'application/json',
-    )
+export var useFetch = (feature, network) =>
+  /**
+   * @template {keyof typeof Roles} Role
+   *
+   * @param {import('@yurkimus/url').URLOptions | undefined} options
+   * @param {RequestInit} init
+   *
+   * @returns {Promise<FetchResults[Feature][Method][Role]>}
+   */
+  function fetcher(options, init) {
+    if (!(feature in Features))
+      throw TypeError(
+        `Feature '${feature}' must be listed in 'Features'.`,
+      )
 
-  if ('cookie' in init)
-    instance.headers.set(
-      'Authorization',
-      cookies.read(Cookies.Token, init.cookie),
-    )
+    if (!(init.method in Methods))
+      throw TypeError(
+        `Method '${init.method}' must be listed in 'Methods'.`,
+      )
 
-  return fetch(instance)
-    .then(message.read)
-    .then(handleMessage.bind(
-      undefined,
-      feature,
-    ))
-}
+    if (!(network in Networks))
+      throw TypeError(
+        `Network '${network}' must be listed in 'Networks'.`,
+      )
 
-/**
- * @type {WeakMap<Function, Map<'onbefore' | 'onfulfilled' | 'onrejected', Set<Function>>>}
- */
-export let Extensions = new WeakMap()
+    if (!(feature in FeaturePathnames))
+      throw TypeError(
+        `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
+      )
 
-/**
- * @template {keyof typeof Features} Feature
- * @template {keyof typeof Methods} Method
- * @template {keyof typeof Networks} Network
- *
- * @param {Feature} feature
- * @param {Method} method
- * @param {Network} network
- */
-export let useFetch = (feature, method, network) => {
-  if (!(feature in Features))
-    throw TypeError(
-      `Feature '${feature}' must be listed in 'Features'.`,
-    )
+    if (!FeatureNetworkUrls.has(feature))
+      throw TypeError(
+        `Feature '${feature}' must be listed in 'FeatureNetworkUrls'.`,
+      )
 
-  if (!(method in Methods))
-    throw TypeError(
-      `Method '${method}' must be listed in 'Methods'.`,
-    )
+    if (!FeatureNetworkUrls.get(feature).has(network))
+      throw TypeError(
+        `Feature's '${feature}' Network '${network}' must be listed in 'FeatureNetworkUrls'.`,
+      )
 
-  if (!(network in Networks))
-    throw TypeError(
-      `Network '${network}' must be listed in 'Networks'.`,
-    )
+    if (!FeatureNetworkUrls.get(feature).get(network))
+      throw TypeError(
+        `Feature's '${feature}' Network '${network}' in 'FeatureNetworkUrls' must have a value.`,
+      )
 
-  if (!(feature in FeaturePathnames))
-    throw TypeError(
-      `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
+    extensions.set(
+      fetcher,
+      new Map([
+        ['onbefore', new Set([])],
+        ['onfulfilled', new Set([])],
+        ['onrejected', new Set([])],
+      ]),
     )
 
-  if (!FeatureNetworkOrigins.has(feature))
-    throw TypeError(
-      `Feature '${feature}' must be listed in 'FeatureNetworkOrigins'.`,
-    )
+    var url = FeatureNetworkUrls
+      .get(feature)
+      .get(network)
+      .call(undefined, options)
 
-  if (!FeatureNetworkOrigins.get(feature).has(network))
-    throw TypeError(
-      `Feature's '${feature}' Network '${network}' must be listed in 'FeatureNetworkOrigins'.`,
-    )
+    var request = new Request(url, init)
 
-  if (!URL.canParse(FeatureNetworkOrigins.get(feature).get(network)))
-    throw TypeError(
-      `Value of 'FeatureNetworkOrigins' '${feature}' '${network}' cannot be parsed as URL.`,
-    )
+    if ('cookie' in init)
+      request.headers.set(
+        'Authorization',
+        cookies.read(Cookies.Token, init.cookie),
+      )
 
-  /**
-   * @template {keyof typeof Roles} Role
-   *
-   * @param {import('@yurkimus/url').URLOptions} options
-   * @param {RequestInit} init
-   *
-   * @returns {Promise<FetchResults[Feature][Method][Role]>}
-   */
-  let fetch = (options, init) => {
-    let onbefore = parameters => {
-      let predicates = Extensions
-        .get(fetch)
-        .get('onbefore')
-
-      return (predicates.size > 0)
-        ? Array
-          .from(predicates)
-          .reduce(
-            (parameters, onbefore) => onbefore(parameters),
-            parameters,
-          )
-        : parameters
-    }
-
-    let onfulfilled = contract => {
-      let predicates = Extensions
-        .get(fetch)
-        .get('onfulfilled')
-
-      return (predicates.size > 0)
-        ? Array
-          .from(predicates)
-          .reduce(
-            (contract, onfulfilled) => onfulfilled(contract),
-            contract,
-          )
-        : contract
-    }
-
-    let onrejected = reason => {
-      let predicates = Extensions
-        .get(fetch)
-        .get('onrejected')
+    if (!request.headers.has('Content-Type'))
+      request.headers.set(
+        'Content-Type',
+        'application/json',
+      )
 
+    /**
+     * @param {ExtensionHooks} name
+     * @param {any} value
+     */
+    var hook = (name, value) =>
       Array
-        .from(predicates)
-        .forEach(onrejected => onrejected(reason))
-
-      throw reason
-    }
+        .from(extensions.get(fetcher).get(name))
+        .reduce((x, f) => f(x), value)
 
     return new Promise((resolve, reject) => {
       try {
-        resolve(onbefore([options, init]))
+        resolve(hook('onbefore', request))
       } catch (reason) {
         reject(reason)
       }
     })
-      .then(([options, init]) =>
-        request(
-          feature,
-          method,
-          network,
-          options,
-          init,
-        )
-      )
-      .then(onfulfilled)
-      .catch(onrejected)
+      .then(fetch)
+      .then(message.read)
+      .then(handleMessage.bind(undefined, feature))
+      .then(hook.bind(undefined, 'onfulfilled'))
+      .catch(hook.bind(undefined, 'onrejected'))
   }
-
-  Extensions.set(
-    fetch,
-    new Map([
-      ['onbefore', new Set([])],
-      ['onfulfilled', new Set([])],
-      ['onrejected', new Set([])],
-    ]),
-  )
-
-  return fetch
-}

package/source/functions/{origins.js → origin.js}

@@ -1,5 +1,9 @@
+import { url } from '@yurkimus/url'
+
 import {
   FeatureNetworkOrigins,
+  FeatureNetworkUrls,
+  FeaturePathnames,
   Features,
   ServiceFeatures,
 } from '../enumerations/features.js'
@@ -27,15 +31,27 @@ export var setFeatureNetworkOrigins = origins => {
           `Feature '${feature}' must be listed in 'Features'.`,
         )
 
+      if (!(feature in FeaturePathnames))
+        throw TypeError(
+          `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
+        )
+
       for (let network in origins[service]) {
         if (!(network in Networks))
           throw TypeError(
             `Network '${network}' must be listed in 'Networks'.`,
           )
 
-        return void FeatureNetworkOrigins
+        var origin = origins[service][network]
+        var pathname = FeaturePathnames[feature]
+
+        FeatureNetworkOrigins
+          .get(feature)
+          .set(network, origin)
+
+        FeatureNetworkUrls
           .get(feature)
-          .set(network, origins[service][network])
+          .set(network, url.bind(undefined, origin, pathname))
       }
     }
   }

package/source/index.d.ts

@@ -21,4 +21,4 @@ export * from './enumerations/roles.js'
 export * from './enumerations/services.js'
 
 export * from './functions/fetch.js'
-export * from './functions/origins.js'
+export * from './functions/origin.js'

package/source/index.js

@@ -12,4 +12,4 @@ export * from './enumerations/roles.js'
 export * from './enumerations/services.js'
 
 export * from './functions/fetch.js'
-export * from './functions/origins.js'
+export * from './functions/origin.js'