@shakerquiz/utilities 0.5.144 → 0.5.146

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@shakerquiz/utilities",
-  "version": "0.5.144",
+  "version": "0.5.146",
   "author": "yurkimus <yurkimus@gmail.com>",
   "license": "ISC",
   "repository": {

package/source/enumerations/entities/role.js

@@ -36,20 +36,35 @@ export var RoleIcon = {
   [Role['manager']]: 'hero/outline/user',
 }
 
-/**
- * @returns {keyof typeof Role | typeof Mode['Unknown']}
- */
+/** @returns {typeof Role[keyof typeof Role]} */
+var infer = value => {
+  if (value in Role)
+    return Role[value]
+  else
+    throw TypeError(`Cannot infer role for value '${value}'.`)
+}
+
 export var inferRole = value => {
   switch (typeof value) {
     case 'string':
-      return value in Role
-        ? Role[value]
-        : Mode['Unknown']
+      return infer(value)
 
     case 'object':
-      return inferRole(value?.role?.name)
+      return infer(value?.role?.name)
+
+    default:
+      return infer(undefined)
+  }
+}
+
+export var inferModedRole = value => {
+  var mode = inferMode(value?.role)
+
+  switch (mode) {
+    case Mode['Known']:
+      return inferRole(value)
 
     default:
-      return Mode['Unknown']
+      return mode
   }
 }

package/source/enumerations/mode.js

@@ -2,52 +2,16 @@ import { Gender } from './gender.js'
 import { Numerosity } from './numerosity.js'
 
 export var Mode = /** @type {const} */ ({
-  'Any': 'Any',
-  'None': 'None',
-  'Single': 'Single',
-  'Many': 'Many',
-  'All': 'All',
   'Known': 'Known',
   'Unknown': 'Unknown',
 })
 
 export var Modes = [
-  Mode['Any'],
-  Mode['None'],
-  Mode['Single'],
-  Mode['Many'],
-  Mode['All'],
   Mode['Known'],
   Mode['Unknown'],
 ]
 
 export var ModeModes = {
-  [Mode['Any']]: [
-    Mode['Any'],
-    Mode['None'],
-    Mode['Single'],
-    Mode['Many'],
-    Mode['All'],
-    Mode['Known'],
-    Mode['Unknown'],
-  ],
-
-  [Mode['None']]: [
-    Mode['None'],
-  ],
-
-  [Mode['Single']]: [
-    Mode['Single'],
-  ],
-
-  [Mode['Many']]: [
-    Mode['Many'],
-  ],
-
-  [Mode['All']]: [
-    Mode['All'],
-  ],
-
   [Mode['Known']]: [
     Mode['Known'],
   ],
@@ -58,11 +22,6 @@ export var ModeModes = {
 }
 
 export var ModeIcon = {
-  [Mode['Any']]: 'hero/outline/square-2-stack',
-  [Mode['None']]: 'hero/outline/x-mark',
-  [Mode['Single']]: 'hero/outline/no-symbol',
-  [Mode['Many']]: 'hero/outline/rectangle-stack',
-  [Mode['All']]: 'hero/outline/check',
   [Mode['Known']]: 'hero/outline/check',
   [Mode['Unknown']]: 'hero/outline/no-symbol',
 }
@@ -70,31 +29,16 @@ export var ModeIcon = {
 export var ModeTitle = {
   [Numerosity['Singular']]: {
     [Gender['Masculine']]: {
-      [Mode['Any']]: 'Любой',
-      [Mode['None']]: 'Отсутствует',
-      [Mode['Single']]: 'Один',
-      [Mode['Many']]: 'Много',
-      [Mode['All']]: 'Все',
       [Mode['Known']]: 'Назначен',
       [Mode['Unknown']]: 'Не назначен',
     },
 
     [Gender['Feminine']]: {
-      [Mode['Any']]: 'Любая',
-      [Mode['None']]: 'Отсутствует',
-      [Mode['Single']]: 'Одна',
-      [Mode['Many']]: 'Много',
-      [Mode['All']]: 'Все',
       [Mode['Known']]: 'Назначена',
       [Mode['Unknown']]: 'Не назначена',
     },
 
     [Gender['Neuter']]: {
-      [Mode['Any']]: 'Любое',
-      [Mode['None']]: 'Отсутствует',
-      [Mode['Single']]: 'Одно',
-      [Mode['Many']]: 'Много',
-      [Mode['All']]: 'Все',
       [Mode['Known']]: 'Назначено',
       [Mode['Unknown']]: 'Не назначено',
     },
@@ -102,31 +46,32 @@ export var ModeTitle = {
 
   [Numerosity['Plural']]: {
     [Gender['Indeterminate']]: {
-      [Mode['Any']]: 'Любые',
-      [Mode['None']]: 'Отсутствуют',
-      [Mode['Single']]: 'Один',
-      [Mode['Many']]: 'Много',
-      [Mode['All']]: 'Все',
       [Mode['Known']]: 'Назначены',
       [Mode['Unknown']]: 'Не назначены',
     },
   },
 }
 
+/** @returns {typeof Mode[keyof typeof Mode]} */
+var infer = value => {
+  if (value in Mode)
+    return Mode[value]
+  else
+    throw TypeError(`Cannot infer mode for value '${value}'.`)
+}
+
 /**
  * @returns {typeof Mode[keyof typeof Mode]}
  */
 export var inferMode = value => {
   switch (typeof value) {
     case 'string':
-      return value in Mode
-        ? Mode[value]
-        : Mode['Unknown']
+      return infer(value)
 
     case 'object':
-      return inferMode(value?.mode)
+      return infer(value?.mode)
 
     default:
-      return Mode['Unknown']
+      return infer(undefined)
   }
 }

package/source/enumerations/quantifier.js

@@ -0,0 +1,113 @@
+import { inferTag } from '../functions/tag.js'
+
+export var Quantifier = /** @type {const} */ ({
+  'Any': 'Any',
+  'None': 'None',
+  'Single': 'Single',
+  'Many': 'Many',
+  'All': 'All',
+})
+
+export var Quantifiers = [
+  Mode['Any'],
+  Mode['None'],
+  Mode['Single'],
+  Mode['Many'],
+  Mode['All'],
+]
+
+export var QuantifierQuantifiers = {
+  [Mode['Any']]: [
+    Mode['Any'],
+    Mode['None'],
+    Mode['Single'],
+    Mode['Many'],
+    Mode['All'],
+  ],
+
+  [Mode['None']]: [
+    Mode['None'],
+  ],
+
+  [Mode['Single']]: [
+    Mode['Single'],
+  ],
+
+  [Mode['Many']]: [
+    Mode['Many'],
+  ],
+
+  [Mode['All']]: [
+    Mode['All'],
+  ],
+}
+
+export var QuantifierTitle = {
+  [Numerosity['Singular']]: {
+    [Gender['Masculine']]: {
+      [Mode['Any']]: 'Любой',
+      [Mode['None']]: 'Отсутствует',
+      [Mode['Single']]: 'Один',
+      [Mode['Many']]: 'Много',
+      [Mode['All']]: 'Все',
+    },
+
+    [Gender['Feminine']]: {
+      [Mode['Any']]: 'Любая',
+      [Mode['None']]: 'Отсутствует',
+      [Mode['Single']]: 'Одна',
+      [Mode['Many']]: 'Много',
+      [Mode['All']]: 'Все',
+    },
+
+    [Gender['Neuter']]: {
+      [Mode['Any']]: 'Любое',
+      [Mode['None']]: 'Отсутствует',
+      [Mode['Single']]: 'Одно',
+      [Mode['Many']]: 'Много',
+      [Mode['All']]: 'Все',
+    },
+  },
+
+  [Numerosity['Plural']]: {
+    [Gender['Indeterminate']]: {
+      [Mode['Any']]: 'Любые',
+      [Mode['None']]: 'Отсутствуют',
+      [Mode['Single']]: 'Один',
+      [Mode['Many']]: 'Много',
+      [Mode['All']]: 'Все',
+    },
+  },
+}
+
+/**
+ * @returns {typeof Quantifier[keyof typeof Quantifier]}
+ */
+export var inferQuantifier = value => {
+  switch (typeof value) {
+    case 'string':
+      return value in Quantifier
+        ? Quantifier[value]
+        : Quantifier['None']
+
+    case 'object':
+      switch (inferTag(value)) {
+        case 'Object':
+          return inferQuantifier(value?.quantifier)
+
+        case 'Array':
+          if (value?.length === 1)
+            return Quantifier['Single']
+          else if (value?.length > 1)
+            return Quantifier['Many']
+          else
+            return Quantifier['None']
+
+        default:
+          return Quantifier['None']
+      }
+
+    default:
+      return Quantifier['None']
+  }
+}

package/source/functions/hydrate-route-pathname.js

@@ -1,16 +1,21 @@
 import { Route, RouteParams, RoutePathname } from '../enumerations/route.js'
-import { guardKey } from '../functions/infer.js'
-import { isTag } from '../functions/tag.js'
 
+import { inferKey } from './infer-key.js'
+import { isTag } from './tag.js'
+
+/**
+ * @param {*} maybeRoute
+ * @param {any[]} maybeRouteParams
+ */
 export var hydrateRoutePathname = (maybeRoute, maybeRouteParams) => {
   if (!isTag('Array', maybeRouteParams))
     throw TypeError(`Parameter 'maybeRouteParams' must be 'Array'.`)
 
-  var route = guardKey(Route, maybeRoute)
+  var route = inferKey(Route, maybeRoute)
 
-  var pathname = guardKey(RoutePathname, route)
+  var pathname = inferKey(RoutePathname, route)
 
-  var params = guardKey(RouteParams, route)
+  var params = inferKey(RouteParams, route)
 
   return params.reduce(
     (pathname, param, index) => pathname.replace(param, maybeRouteParams[index]),

package/source/functions/infer-key.js

@@ -0,0 +1,13 @@
+/**
+ * @template {any} E
+ *
+ * @param {E} Enumeration
+ *
+ * @returns {E[keyof E]}
+ */
+export var inferKey = (Enumeration, value) => {
+  if (value in Enumeration)
+    return Enumeration[value]
+  else
+    throw TypeError(`Cannot infer enum's '${Object.values(Enumeration).join(', ')}' key for value '${value}'.`)
+}

package/source/functions/route-key.js

@@ -1,18 +1,15 @@
 import { Method } from '../enumerations/method.js'
-import { Mode } from '../enumerations/mode.js'
-import { hydrateRoutePathname } from '../functions/hydrate-route-pathname.js'
-import { guardKey } from '../functions/infer.js'
+
+import { hydrateRoutePathname } from './hydrate-route-pathname.js'
+import { inferKey } from './infer-key.js'
 
 /**
- * @param {keyof typeof import('@shakerquiz/utilities').Method} maybeMethod
- * @param {keyof typeof import('@shakerquiz/utilities').Route} maybeRoute
+ * @param {any} maybeMethod
+ * @param {any} maybeRoute
  * @param {any[]} maybeParameters
  */
-export var routeKey = (maybeMethod, maybeRoute, maybeParameters) => {
-  var method = guardKey(Method, maybeMethod)
-
-  if (method === Mode['Unknown'])
-    throw TypeError(`Cannot infer method of '${maybeMethod}'.`)
-
-  return method + '/' + hydrateRoutePathname(maybeRoute, maybeParameters)
-}
+export var routeKey = (maybeMethod, maybeRoute, maybeParameters) =>
+  ''
+  + inferKey(Method, maybeMethod)
+  + '/'
+  + hydrateRoutePathname(maybeRoute, maybeParameters)

package/source/index.js

@@ -32,6 +32,6 @@ export * from './enumerations/venue/city-mode.js'
 export * from './enumerations/venue/status.js'
 
 export * from './functions/hydrate-route-pathname.js'
-export * from './functions/infer.js'
+export * from './functions/infer-key.js'
 export * from './functions/route-key.js'
 export * from './functions/tag.js'

package/source/functions/infer.js

@@ -1,37 +0,0 @@
-import { Mode } from '../enumerations/mode.js'
-
-/**
- * @template {*} E
- *
- * @param {E} Enumeration
- * @param {E[keyof E]} value
- *
- * @returns {E[keyof E]}
- */
-export var inferKey = (Enumeration, value) =>
-  value in Enumeration
-    ? Enumeration[value]
-    : Mode['Unknown']
-
-/**
- * @template {*} E
- *
- * @param {E} Enumeration
- * @param {E[keyof E]} value
- */
-export var guardKey = (Enumeration, value) => {
-  var key = inferKey(Enumeration, value)
-
-  if (key === Mode['Unknown'])
-    throw TypeError(`Cannot infer enum key '${value}'.`)
-
-  return key
-}
-
-/**
- * @template {*} E
- *
- * @param {E} Enumeration
- * @param {E[keyof E]} value
- */
-export var isKey = (Enumeration, value) => value in Enumeration