@shakerquiz/utilities 0.3.9 → 0.3.10

package/source/functions/fetch.js

@@ -2,45 +2,29 @@ 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,
-  FeaturePathnames,
-  Features,
-  ServiceFeatureNetworkURLs,
-  ServiceFeatures,
-} from '../enumerations/features.js'
+import { Features, FeatureServiceDefaults } from '../enumerations/features.js'
 import { Kinds } from '../enumerations/kinds.js'
+import { Methods } from '../enumerations/methods.js'
 import { Networks } from '../enumerations/networks.js'
-import { RequestMethods } from '../enumerations/request-methods.js'
-import { Services } from '../enumerations/services.js'
+import { ServiceFeatures, Services } from '../enumerations/services.js'
+import { getFeatureOrigin } from './origin.js'
+import { getFeaturePathname } from './pathname.js'
 
-/**
- * @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]) => {
+var fulfillment = (kind, [response, body]) => {
   switch (response.status) {
     case 200:
     case 201:
       return body
 
     case 204:
-      switch (FeatureKinds[feature]) {
-        case Kinds.Item:
+      switch (kind) {
+        case Kinds.Unit:
           return null
 
-        case Kinds.List:
+        case Kinds.Set:
           return []
       }
 
@@ -53,92 +37,70 @@ var handleMessage = (feature, [response, body]) => {
 }
 
 /**
- * @param {Function} fetcher
- * @param {ExtensionHooks} name
- * @param {any} value
- */
-var extension = (fetcher, name, value) =>
-  Array
-    .from(extensions.get(fetcher).get(name))
-    .reduce((x, f) => f(x), value)
-
-/**
+ * @template {Feature} F
  * @template {Service} S
- * @template {typeof import('../enumerations/features.js').ServiceFeatures[S][number]} F
  * @template {Network} N
+ * @template {Kind} K
  *
- * @param {S} service
  * @param {F} feature
+ * @param {S} service
  * @param {N} network
+ * @param {K} kind
  */
-export var useFetch = (service, feature, network) => {
+export var useFeatureFetch = (
+  feature,
+  kind = Kinds.Unit,
+  service = FeatureServiceDefaults[feature],
+  network = Networks.Public,
+) => {
+  if (!(feature in Features))
+    throw TypeError(
+      `Feature '${feature}' must be a member of 'Features'.`,
+    )
+
+  if (!(kind in Kinds))
+    throw TypeError(
+      `Kind '${kind}' must be a member of 'Kinds'.`,
+    )
+
+  if (!(service in Services))
+    throw TypeError(
+      `Service '${service}' must be a member of 'Services'.`,
+    )
+
+  if (!(network in Networks))
+    throw TypeError(
+      `Network '${network}' must be a member of 'Networks'.`,
+    )
+
+  if (!ServiceFeatures[service].includes(feature))
+    throw TypeError(
+      `Feature '${feature}' must be a member of 'ServiceFeatures[${service}]'.`,
+    )
+
   /**
-   * @template {RequestMethod} [M='GET']
-   * @template {Role} [R='default']
-   *
-   * @param {import('@yurkimus/url').URLOptions | undefined} options
+   * @param {import('@yurkimus/url').URLOptions} input
    * @param {RequestInit} init
    *
-   * @returns {Promise<FetchResults[S][F][M][R]>}
+   * @returns {Promise<any>}
    */
-  var fetcher = (options, init) => {
-    if (!(service in Services))
-      throw TypeError(
-        `Service '${service}' is not listed in 'Services'.`,
-      )
-
-    if (!(feature in Features))
-      throw TypeError(
-        `Feature '${feature}' is not listed in 'Features'.`,
-      )
-
-    if (!(feature in FeaturePathnames))
+  // @template {Method} [M='GET']
+  // FeatureFetchResponses[F][S][M][R][K]
+  // FeatureFetchResponses[F][S][M][R][K]
+  return (input, init) => {
+    if (!(init.method in Methods))
       throw TypeError(
-        `Feature '${feature}' is not listed in 'FeaturePathnames'.`,
+        `Method '${init.method}' is not listed in 'Methods'.`,
       )
 
-    if (!ServiceFeatures[service].includes(feature))
-      throw TypeError(
-        `Feature '${feature}' is not listed in 'ServiceFeatures[${service}]'.`,
-      )
-
-    if (!(init.method in RequestMethods))
-      throw TypeError(
-        `Method '${init.method}' is not listed in 'RequestMethods'.`,
-      )
-
-    if (!(network in Networks))
-      throw TypeError(
-        `Network '${network}' is not listed in 'Networks'.`,
-      )
-
-    if (!ServiceFeatureNetworkURLs.has(service))
-      throw TypeError(
-        `Service '${service}' is not listed in 'ServiceFeatureNetworkURLs'.`,
-      )
-
-    if (!ServiceFeatureNetworkURLs.get(service).has(feature))
-      throw TypeError(
-        `Feature '${feature}' is not listed in 'ServiceFeatureNetworkURLs[${service}]'.`,
-      )
-
-    if (!ServiceFeatureNetworkURLs.get(service).get(feature).has(network))
-      throw TypeError(
-        `Network '${network}' is not listed in 'ServiceFeatureNetworkURLs[${service}][${feature}]'.`,
-      )
-
-    if (!ServiceFeatureNetworkURLs.get(service).get(feature).get(network))
-      throw TypeError(
-        `Network '${network}' of 'ServiceFeatureNetworkURLs[${service}][${feature}]' has no value.`,
-      )
-
-    var url = ServiceFeatureNetworkURLs
-      .get(service)
-      .get(feature)
-      .get(network)
-      .call(undefined, options)
-
-    var request = new Request(url, init)
+    var request = new Request(
+      url(
+        getFeatureOrigin(feature, service, network),
+        getFeaturePathname(feature, kind),
+        input,
+      ),
+      init,
+    )
 
     if ('cookie' in init)
       request.headers.set(
@@ -152,30 +114,9 @@ export var useFetch = (service, feature, network) => {
         'application/json',
       )
 
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(extension(fetcher, 'onbefore', request))
-      } catch (reason) {
-        reject(reason)
-      }
-    })
-      .then(fetch)
+    return globalThis
+      .fetch(request)
       .then(message.read)
-      .then(handleMessage.bind(undefined, feature))
-      .then(extension.bind(undefined, fetcher, 'onfulfilled'))
-      .catch(reason => {
-        throw extension(fetcher, 'onrejected', reason)
-      })
+      .then(fulfillment.bind(undefined, kind))
   }
-
-  extensions.set(
-    fetcher,
-    new Map([
-      ['onbefore', new Set([])],
-      ['onfulfilled', new Set([])],
-      ['onrejected', new Set([])],
-    ]),
-  )
-
-  return fetcher
 }

package/source/functions/origin.d.ts

@@ -1 +1,213 @@
-export function setServiceNetworkOrigins(origins: Partial<Record<Service, Partial<Record<Network, URL["origin"]>>>>): void;
+export function getFeatureOrigin(feature: Feature, service?: Service, network?: Network): any;
+export function setFeatureOrigin(origins: Partial<Record<Feature, Partial<Record<Service, Partial<Record<Network, URL["origin"]>>>>>>): {
+    Checkin: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    City: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    Game: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    Registration: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    Theme: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    User: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+    Venue: {
+        Backend: {
+            Docker: string;
+            Public: string;
+        };
+        Games: {
+            Docker: string;
+            Public: string;
+        };
+        Locations: {
+            Docker: string;
+            Public: string;
+        };
+        Users: {
+            Docker: string;
+            Public: string;
+        };
+        Admin: {
+            Docker: string;
+            Public: string;
+        };
+        Landing: {
+            Docker: string;
+            Public: string;
+        };
+        MiniApp: {
+            Docker: string;
+            Public: string;
+        };
+    };
+};

package/source/functions/origin.js

@@ -1,68 +1,106 @@
-import { url } from '@yurkimus/url'
-
 import {
-  FeaturePathnames,
   Features,
-  ServiceFeatureNetworkURLs,
-  ServiceFeatures,
-  ServiceNetworkOrigins,
+  FeatureServiceDefaults,
+  FeatureServiceNetworkOrigins,
 } from '../enumerations/features.js'
 import { Networks } from '../enumerations/networks.js'
 import { Services } from '../enumerations/services.js'
 
 /**
- * @param {Partial<Record<Service, Partial<Record<Network, URL['origin']>>>>} origins
- *
- * @returns {void}
+ * @param {Feature} feature
+ * @param {Service} [service]
+ * @param {Network} [network]
+ */
+export var getFeatureOrigin = (
+  feature,
+  service = FeatureServiceDefaults[feature],
+  network = Networks.Public,
+) => {
+  if (!(feature in Features))
+    throw TypeError(
+      `Parameter 'feature' must be a member of 'Features'.`,
+    )
+
+  if (!(service in Services))
+    throw TypeError(
+      `Parameter 'service' must be a member of 'Services'.`,
+    )
+
+  if (!(network in Networks))
+    throw TypeError(
+      `Parameter 'network' must be a member of 'Networks'.`,
+    )
+
+  if (!(feature in FeatureServiceNetworkOrigins))
+    throw TypeError(
+      `Feature '${feature}' is not defined in 'FeatureServiceNetworkOrigins'.`,
+    )
+
+  if (!(service in FeatureServiceNetworkOrigins[feature]))
+    throw TypeError(
+      `Feature's '${feature}' Service '${service}' is not defined in 'FeatureServiceNetworkOrigins[${feature}]'.`,
+    )
+
+  if (!(network in FeatureServiceNetworkOrigins[feature][service]))
+    throw TypeError(
+      `Feature's '${feature}' Service '${service}' Network '${network}' is not defined in 'FeatureServiceNetworkOrigins[${feature}][${network}]'.`,
+    )
+
+  if (!URL.canParse(FeatureServiceNetworkOrigins[feature][service][network]))
+    throw TypeError(
+      `Feature's '${feature}' Service '${service}' Network '${network}' must be URL-like.`,
+    )
+
+  return FeatureServiceNetworkOrigins[feature][service][network]
+}
+
+/**
+ * @param {Partial<Record<Feature, Partial<Record<Service, Partial<Record<Network, URL['origin']>>>>>>} origins
  */
-export var setServiceNetworkOrigins = origins => {
-  for (var service in origins) {
-    if (!(service in Services))
+export var setFeatureOrigin = origins => {
+  for (var feature in origins) {
+    if (!(feature in Features))
       throw TypeError(
-        `Service '${service}' must be listed in 'Services'.`,
+        `Parameter 'feature' must be a member of 'Features'.`,
       )
 
-    for (var network in origins[service]) {
-      if (!(network in Networks))
+    if (!(feature in FeatureServiceNetworkOrigins))
+      throw TypeError(
+        `Feature '${feature}' is not defined 'FeatureServiceNetworkOrigins'.`,
+      )
+
+    for (var service in origins[feature]) {
+      if (!(service in Services))
         throw TypeError(
-          `Network '${network}' must be listed in 'Networks'.`,
+          `Parameter 'service' must be a member of 'Services'.`,
         )
 
-      var origin = origins[service][network]
-
-      ServiceNetworkOrigins
-        .get(service)
-        .set(network, origin)
-
-      for (var feature of ServiceFeatures[service]) {
-        if (!(feature in Features))
-          throw TypeError(
-            `Feature '${feature}' must be listed in 'Features'.`,
-          )
+      if (!(service in FeatureServiceNetworkOrigins[feature]))
+        throw TypeError(
+          `Feature's '${feature}' Service '${service}' is not defined 'FeatureServiceNetworkOrigins[${feature}]'.`,
+        )
 
-        if (!(feature in FeaturePathnames))
+      for (var network in origins[feature][service]) {
+        if (!(network in Networks))
           throw TypeError(
-            `Feature '${feature}' must be listed in 'FeaturePathnames'.`,
+            `Parameter 'network' must be a member of 'Networks'.`,
           )
 
-        if (!ServiceFeatureNetworkURLs.has(service))
+        if (!(network in FeatureServiceNetworkOrigins[feature][service]))
           throw TypeError(
-            `Service '${service}' must be listed in 'ServiceFeatureNetworkURLs'.`,
+            `Feature's '${feature}' Service '${service}' Network '${network}' is not defined 'FeatureServiceNetworkOrigins[${feature}][${service}]'.`,
           )
 
-        if (!ServiceFeatureNetworkURLs.get(service).has(feature))
+        if (!URL.canParse(origins[feature][service][network]))
           throw TypeError(
-            `Feature '${feature}' must be listed in 'ServiceFeatureNetworkURLs[${service}]'.`,
+            `Feature's '${feature}' Service '${service}' Network '${network}' must be URL-like.`,
           )
 
-        ServiceFeatureNetworkURLs
-          .get(service)
-          .get(feature)
-          .set(
-            network,
-            url.bind(undefined, origin, FeaturePathnames[feature]),
-          )
+        FeatureServiceNetworkOrigins[feature][service][network] =
+          origins[feature][service][network]
       }
     }
   }
+
+  return FeatureServiceNetworkOrigins
 }

package/source/functions/pathname.d.ts

@@ -0,0 +1 @@
+export function getFeaturePathname(feature: Feature, kind?: Kind): any;

package/source/functions/pathname.js

@@ -0,0 +1,40 @@
+import { is } from '@yurkimus/types'
+
+import { FeatureKindPathnames, Features } from '../enumerations/features.js'
+import { Kinds } from '../enumerations/kinds.js'
+
+/**
+ * @param {Feature} feature
+ * @param {Kind} [kind]
+ */
+export var getFeaturePathname = (
+  feature,
+  kind = Kinds.Unit,
+) => {
+  if (!(feature in Features))
+    throw TypeError(
+      `Parameter 'feature' must be a member of 'Features'.`,
+    )
+
+  if (!(kind in Kinds))
+    throw TypeError(
+      `Parameter 'kind' must be a member of 'Kinds'.`,
+    )
+
+  if (!(feature in FeatureKindPathnames))
+    throw TypeError(
+      `Feature '${feature}' is not defined in 'FeatureKindPathnames'.`,
+    )
+
+  if (!(kind in FeatureKindPathnames[feature]))
+    throw TypeError(
+      `Feature's '${feature}' Kind '${kind}' is not defined in 'FeatureKindPathnames[${feature}]'.`,
+    )
+
+  if (!is('String', FeatureKindPathnames[feature][kind]))
+    throw TypeError(
+      `Feature's '${feature}' Kind '${kind}' must be a 'String'.`,
+    )
+
+  return FeatureKindPathnames[feature][kind]
+}

package/source/functions/url.d.ts

@@ -0,0 +1 @@
+export function getFeatureUrl(feature: Feature, service?: Service, network?: Network, kind?: Kind): URL;

package/source/functions/url.js

@@ -0,0 +1,48 @@
+import { DomainServiceDefaults } from '../enumerations/domains.js'
+import { Features } from '../enumerations/features.js'
+import { Kinds } from '../enumerations/kinds.js'
+import { Networks } from '../enumerations/networks.js'
+import { ProcedureServiceDefaults } from '../enumerations/procedures.js'
+import { Services } from '../enumerations/services.js'
+
+import { getFeatureOrigin } from './origin.js'
+import { getFeaturePathname } from './pathname.js'
+
+/**
+ * @param {Feature} feature
+ * @param {Service} service
+ * @param {Network} [network]
+ * @param {Kind} [kind]
+ */
+export var getFeatureUrl = (
+  feature,
+  service = DomainServiceDefaults[feature]
+    ?? ProcedureServiceDefaults[feature],
+  network = Networks.Public,
+  kind = Kinds.Unit,
+) => {
+  if (!(feature in Features))
+    throw TypeError(
+      `Parameter 'feature' must be a member of 'Features'.`,
+    )
+
+  if (!(service in Services))
+    throw TypeError(
+      `Parameter 'service' must be a member of 'Services'.`,
+    )
+
+  if (!(network in Networks))
+    throw TypeError(
+      `Parameter 'network' must be a member of 'Networks'.`,
+    )
+
+  if (!(kind in Kinds))
+    throw TypeError(
+      `Parameter 'kind' must be a member of 'Kinds'.`,
+    )
+
+  return new URL(
+    getFeaturePathname(feature, kind),
+    getFeatureOrigin(feature, service, network),
+  )
+}