@witchcraft/spellcraft 0.0.1

package/src/core/setCommandProp.ts

@@ -0,0 +1,140 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { crop } from "@alanscodelog/utils/crop"
+import { indent } from "@alanscodelog/utils/indent"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { setCommandsProp } from "./setCommandsProp.js"
+import { setShortcutProp } from "./setShortcutProp.js"
+
+import { KnownError } from "../helpers/KnownError.js"
+import { errorTextAdd } from "../internal/errorTextAdd.js"
+import { type CanHookCommandProps, type CanHookErrors, type Command, type CommandSetEntries, type Manager, type MultipleErrors, SHORTCUT_ERROR } from "../types/index.js"
+
+
+const canHookable: CanHookCommandProps[] = ["condition", "execute"]
+
+/**
+ * Sets a settable command property.
+ *
+ * You should not use this to set key state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ * Note that while the manager argument is always required, for unmanaged properties you can pass {} and for most others you can pass a partial manager if needed. This is because it's very difficult to keep the heavy per prop types and allow the manager to be optional in these cases.
+ *
+ */
+export function setCommandProp<
+	TEntries extends CommandSetEntries,
+	TProp extends keyof CommandSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	/** Command is mutated if check is not "only". */
+	command: Command,
+	prop: TProp,
+	val: TEntry["val"],
+	manager: (TEntry["manager"] extends never ? unknown : TEntry["manager"]) & { hooks?: THooks },
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Command,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetCommandProp">
+> {
+	if (check) {
+		switch (prop) {
+			case "name": {
+				castType<TEntries["name"]["manager"]>(manager)
+				castType<TEntries["name"]["val"]>(val)
+				const s = manager.options.stringifier
+				const existing = manager.commands.entries[val as string]
+				if (existing) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.DUPLICATE_COMMAND,
+						errorTextAdd(
+							"Command",
+							val as string,
+							s.stringify(existing),
+							s.stringify(command)
+						),
+						{ existing, self: manager.commands }
+					))
+				}
+				// note that the old command being missing is NOT an error, see Command.name
+
+				// we artificially add the command so we don't get errors that it's unknown
+				const managerClone = {
+					...manager,
+					commands: {
+						...manager.commands,
+						entries: {
+							...manager.commands.entries,
+							[val]: { ...command, name: val }
+						}
+					}
+				}
+
+				const shortcutErrors = []
+				for (const shortcut of manager.shortcuts.entries) {
+					if (shortcut.command === command.name) {
+						// we should only receive hook errors
+						const res = setShortcutProp(shortcut, "command", val, managerClone, { check: "only" })
+						if (res.isError) shortcutErrors.push(res.error)
+					}
+				}
+				if (shortcutErrors.length > 0) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.MULTIPLE_ERRORS,
+						crop`
+							Received multiple errors attempting to change command name from ${command.name} to ${val}: 
+							${indent(shortcutErrors.map(_ => _.message).join("\n"), 7)}
+							`,
+						{ errors: shortcutErrors }
+					))
+				}
+				break
+			}
+
+			default: break
+		}
+
+		if (manager?.hooks && "canSetCommandProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks.canSetCommandProp?.(command, prop as any, val)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+
+	if (prop === "name") {
+		castType<TEntries["name"]["manager"]>(manager)
+		castType<TEntries["name"]["val"]>(val)
+
+
+		setCommandsProp("entries@add", { ...command, name: val }, manager).unwrap()
+		const old = command.name
+		const oldCommand = manager.commands.entries[old]
+		for (const shortcut of manager.shortcuts.entries) {
+			if (shortcut.command === old) {
+				setShortcutProp(shortcut, "command", val, manager).unwrap()
+			}
+		}
+		// only remove if it existed
+		if (manager.commands.entries[old]) {
+			setCommandsProp("entries@remove", oldCommand, manager).unwrap()
+		}
+	} else {
+		(command as any)[prop] = val
+	}
+	if (manager?.hooks && "onSetCommandProp" in manager.hooks!) {
+		manager?.hooks?.onSetCommandProp?.(command, prop as any, val)
+	}
+
+	return Ok(command) satisfies Result<Command, never> as any
+}
+

package/src/core/setCommandsProp.ts

@@ -0,0 +1,128 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { KnownError } from "../helpers/KnownError.js"
+import { errorTextAdd } from "../internal/errorTextAdd.js"
+import { errorTextInUse } from "../internal/errorTextInUse.js"
+import { errorTextRemove } from "../internal/errorTextRemove.js"
+import { type CanHookCommandsProps, type CanHookErrors, type Command, type Commands, type CommandsSetEntries, type Manager, type MultipleErrors, SHORTCUT_ERROR } from "../types/index.js"
+
+
+const canHookable: CanHookCommandsProps[] = ["entries@add", "entries@remove"]
+
+
+/**
+ * Sets a settable command property.
+ *
+ * You should not use this to set command state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ */
+export function setCommandsProp<
+	TEntries extends CommandsSetEntries,
+	TProp extends keyof CommandsSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	prop: TProp,
+	val: TEntry["val"],
+	/** Commands is mutated if check is not "only". */
+	manager: TEntry["manager"] & { hooks?: THooks },
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Command,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetCommandsProp">
+> {
+	const commands = manager.commands
+	const s = manager.options.stringifier
+	if (check) {
+		switch (prop) {
+			case "entries@add": {
+				castType<TEntries["entries@add"]["val"]>(val)
+				castType<TEntries["entries@add"]["manager"]>(manager)
+				const command = val
+				const existing = commands.entries[command.name]
+
+				if (existing) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.DUPLICATE_COMMAND,
+						errorTextAdd(
+							"Command",
+							s.stringifyCommand(existing.name, manager),
+							s.stringifyCommand(existing.name, manager),
+							s.stringifyCommand(command.name, manager)
+						),
+						{ existing, self: commands }
+					))
+				}
+
+				break
+			}
+			case "entries@remove": {
+				castType<TEntries["entries@remove"]["val"]>(val)
+				castType<TEntries["entries@remove"]["manager"]>(manager)
+
+				const command = val
+				if (!commands.entries[command.name]) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.MISSING,
+						errorTextRemove(
+							"Command",
+							s.stringify(command),
+							s.stringifyList("commands", Object.values(commands.entries))
+						),
+						{ entry: command.name, self: commands }
+					))
+				}
+
+				const inUseShortcuts = manager.shortcuts.entries.filter(shortcut => shortcut.command === command.name)
+				if (inUseShortcuts.length > 0) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.COMMAND_IN_USE,
+						errorTextInUse(
+							"command",
+							s.stringify(command),
+							s.stringifyList("shortcuts", inUseShortcuts, manager)
+						),
+						{ inUseShortcuts }))
+				}
+				break
+			}
+			default: break
+		}
+		if (manager?.hooks && "canSetCommandsProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks?.canSetCommandsProp?.(commands, prop as any, val as any)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+	switch (prop) {
+		case "entries@add": {
+			const command = val as any as Command
+			commands.entries[command.name] = command
+			break
+		}
+		case "entries@remove": {
+			const command = val as any as Command
+			delete commands.entries[command.name]
+			break
+		}
+		default:
+			(commands as any)[prop] = val
+			break
+	}
+
+	manager.hooks?.onSetCommandsProp?.(commands, prop as any, val as any)
+
+	return Ok(commands) satisfies Result<Commands, never> as any
+}
+

package/src/core/setKeyProp.ts

@@ -0,0 +1,80 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { crop } from "@alanscodelog/utils/crop"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+import { set } from "@alanscodelog/utils/set"
+
+import { KnownError } from "../helpers/KnownError.js"
+import type { CanHookErrors, Key, KeySetEntries, Manager, MultipleErrors, OnHookKeyProps } from "../types/index.js"
+import { SHORTCUT_ERROR } from "../types/index.js"
+
+
+const canHookable: OnHookKeyProps[] = ["x", "y", "width", "height", "label", "enabled", "render", "classes"]
+/**
+ * Sets a settable key property.
+ *
+ * You should not use this to set key state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ * Note that while the manager argument is always required, for unmanaged properties you can pass {} and for most others you can pass a partial manager if needed. This is because it's very difficult to keep the heavy per prop types and allow the manager to be optional in these cases.
+ */
+export function setKeyProp<
+	TEntries extends KeySetEntries,
+	TProp extends keyof KeySetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	/** Key is mutated if check is not "only". */
+	key: Key,
+	prop: TProp,
+	val: TEntry["val"],
+	manager: (TEntry["manager"] extends never ? unknown : TEntry["manager"]) & { hooks?: THooks },
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Key,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<THooks extends never ? never : THooks, "canSetKeyProp">
+> {
+	if (check) {
+		switch (prop) {
+			case "toggleOnPressed":
+			case "toggleOffPressed":
+			case "pressed": {
+				castType<TEntries["pressed"]["manager"]>(manager)
+				const s = manager.options.stringifier
+				if (!key.enabled && val === true) {
+					return Err(
+						new KnownError(SHORTCUT_ERROR.CANNOT_SET_WHILE_DISABLED, crop`
+							The "${prop}" property cannot be set to true while a key is disabled. (Key: ${s.stringify(key, manager)})
+						`, { key })
+					)
+				}
+				break
+			}
+			default: break
+		}
+
+		if (manager?.hooks && "canSetKeyProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks.canSetKeyProp?.(key, prop as any, val as any)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+	if (prop.includes(".")) {
+		set(key, prop.split("."), val)
+	} else {
+		(key as any)[prop] = val
+	}
+
+	manager?.hooks?.onSetKeyProp?.(key, prop, val)
+
+	return Ok(key) satisfies Result<Key, never> as any
+}
+

package/src/core/setKeysProp.ts

@@ -0,0 +1,205 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { calculateLayoutSize } from "../helpers/calculateLayoutSize.js"
+import { KnownError } from "../helpers/KnownError.js"
+import { areValidVariants } from "../internal/areValidVariants.js"
+import { errorTextAdd } from "../internal/errorTextAdd.js"
+import { errorTextInUse } from "../internal/errorTextInUse.js"
+import { errorTextRemove } from "../internal/errorTextRemove.js"
+import { type CanHookErrors, type CanHookKeysProps, type Key, type Keys, type KeysSetEntries, type Manager, type MultipleErrors, SHORTCUT_ERROR } from "../types/index.js"
+import { containsKey } from "../utils/containsKey.js"
+
+
+const canHookable: CanHookKeysProps[] = ["entries@add", "entries@remove"]
+
+/**
+ * Sets a settable {@link Keys} property.
+ */
+export function setKeysProp<
+	TEntries extends KeysSetEntries,
+	TProp extends keyof KeysSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	prop: TProp,
+	val: TEntry["val"],
+	manager: TEntry["manager"] & { hooks?: THooks },
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Key,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetKeysProp">
+> {
+	const keys = manager.keys
+	if (check) {
+		switch (prop) {
+			case "entries@add": {
+				castType<TEntries["entries@add"]["val"]>(val)
+				castType<TEntries["entries@add"]["manager"]>(manager)
+
+				const s = manager.options.stringifier
+				const key = val
+				// we only need to check .entries at this point
+				const existing = keys.entries[key.id]
+
+				if (existing) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.DUPLICATE_KEY,
+						errorTextAdd(
+							"Key",
+							s.stringify(existing, manager),
+							s.stringify(existing, manager),
+							s.stringify(key, manager)
+						),
+						{ existing, self: keys }
+					))
+				}
+				const areValidVariantsRes = areValidVariants(key, manager)
+				if (areValidVariantsRes.isError) return areValidVariantsRes
+
+				break
+			}
+			case "entries@remove": {
+				castType<TEntries["entries@remove"]["val"]>(val)
+				castType<TEntries["entries@remove"]["manager"]>(manager)
+				const s = manager.options.stringifier
+
+				const key = val
+				if (!keys.entries[key.id]) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.MISSING,
+						errorTextRemove(
+							"Key",
+							s.stringify(key),
+							s.stringifyList("keys", Object.values(keys.entries))
+						),
+						{ entry: key.id, self: keys }
+					)) as any
+				}
+
+				const inUseShortcuts = manager.shortcuts.entries.filter(shortcut => containsKey(shortcut.chain, key.id, keys))
+
+				if (inUseShortcuts.length > 0) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.KEY_IN_USE,
+						errorTextInUse(
+							"key",
+							s.stringify(key),
+							s.stringifyList("shortcuts", inUseShortcuts, manager)),
+
+						{ inUseShortcuts }))
+				}
+
+				break
+			}
+			default: break
+		}
+		if (manager.hooks && "canSetKeysProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks.canSetKeysProp?.(keys, prop as any, val as any)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+	switch (prop) {
+		case "entries@add": {
+			castType<TEntries["entries@add"]["val"]>(val)
+			castType<TEntries["entries@add"]["manager"]>(manager)
+
+			const key = val
+			keys.entries[key.id] = key
+			if (key.isToggle === "native") {
+				setKeysProp("nativeToggleKeys", [
+					...keys.nativeToggleKeys,
+					key.id
+				], manager).unwrap()
+			}
+			if (key.isModifier === "native") {
+				setKeysProp("nativeModifierKeys", [
+					...keys.nativeModifierKeys,
+					key.id
+				], manager).unwrap()
+			}
+			if (key.isToggle) {
+				setKeysProp(`toggles@add@${key.toggleOnId}`, key, manager).unwrap()
+				setKeysProp(`toggles@add@${key.toggleOffId}`, key, manager).unwrap()
+			}
+			if (key.variants) {
+				for (const variant of key.variants) {
+					setKeysProp(`variants@add@${variant}`, key.id, manager).unwrap()
+				}
+			}
+			if (keys.autoManageLayout) {
+				setKeysProp("layout", calculateLayoutSize(keys), manager).unwrap()
+			}
+			break
+		}
+		case "entries@remove": {
+			const key = val as any as Key
+			delete keys.entries[key.id]
+			if (key.isToggle === "native") {
+				setKeysProp("nativeToggleKeys", keys.nativeToggleKeys.filter(k => k !== key.id), manager).unwrap()
+			}
+			if (key.isModifier === "native") {
+				setKeysProp("nativeModifierKeys", keys.nativeToggleKeys.filter(k => k !== key.id), manager).unwrap()
+			}
+
+			if (key.isToggle) {
+				setKeysProp(`toggles@remove@${key.toggleOnId}`, key, manager).unwrap()
+				setKeysProp(`toggles@remove@${key.toggleOffId}`, key, manager).unwrap()
+			}
+			if (key.variants) {
+				for (const variant of key.variants) {
+					setKeysProp(`variants@remove@${variant}`, key.id, manager).unwrap()
+				}
+			}
+			if (keys.autoManageLayout) {
+				setKeysProp("layout", calculateLayoutSize(keys), manager).unwrap()
+			}
+			break
+		}
+		default:
+			if (prop.startsWith("toggles@add@")) {
+				const name = prop.slice("toggles@add@".length)
+				keys.toggles[name] = val as Key
+			} else if (prop.startsWith("toggles@remove@")) {
+				const name = prop.slice("toggles@remove@".length)
+				delete keys.toggles[name]
+			} else if (prop.startsWith("variants@add@")) {
+				const variant = prop.slice("variants@add@".length)
+				const existing = keys.variants[variant]
+					? [...keys.variants[variant]]
+					: []
+				existing.push(val as string)
+				keys.variants[variant] = existing
+			} else if (prop.startsWith("variants@remove@")) {
+				const variant = prop.slice("variants@remove@".length)
+				const existing = keys.variants[variant]
+					? [...keys.variants[variant]]
+					: []
+				existing.splice(existing.indexOf(val as string), 1)
+				if (existing.length > 0) {
+					keys.variants[variant] = existing
+				} else {
+					delete keys.variants[variant]
+				}
+			} else {
+				(keys as any)[prop] = val
+			}
+			break
+	}
+
+	manager.hooks?.onSetKeysProp?.(keys, prop as any, val as any)
+
+	return Ok(keys) satisfies Result<Keys, never> as any
+}
+

package/src/core/setManagerProp.ts

@@ -0,0 +1,111 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+import { set } from "@alanscodelog/utils/set"
+import { unreachable } from "@alanscodelog/utils/unreachable"
+
+import { isValidManager } from "../helpers/isValidManager.js"
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { safeSetManagerChain } from "../helpers/safeSetManagerChain.js"
+import { areValidKeys } from "../internal/areValidKeys.js"
+import { type CanHookErrors, type CanHookManagerProps, type ChainError, type Manager, type ManagerSetEntries, type MultipleErrors, SHORTCUT_ERROR } from "../types/index.js"
+import { cloneChain } from "../utils/cloneChain.js"
+
+
+const canHookable: CanHookManagerProps[] = ["state.chain", "shortcuts", "commands", "keys"]
+
+/**
+ * Safely sets a settable manager property.
+ *
+ * You should not use this to set properties the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ * If you need to set the chain, use {@link safeSetManagerChain}.
+ *
+ * If enabling/disabling {@link Manager.state.isRecording} it's suggested you use {@link safeSetManagerChain} just before.
+ *
+ * # How to set multiple manager properties safely (i.e. batch replace shortcuts/commands/keys)
+ *
+ * This can be an issue because there isn't a way to tell the manager you want to replace *multiple* properties and it might be impossible to, for example, replace commands with a smaller subset but not have it error even if you're planning to replace the shortcuts so they don't contain missing commands.
+ *
+ * To achieve this, you can shallow clone the manager, change all the properties you want directly, then validate it's state by using isValidManager which is what this function does internally.
+ *
+ * Once you know it's valid, detach the old manager and attach the new one.
+ * ```ts
+ * const clone = {...manager, keys: newKeys, shortcuts: newShortcuts}
+ *
+ * if (isValidManager(manager)) {
+ * detach(manager, ...)
+ * 	attach(clone, ...)
+ * }
+ * ```
+ */
+
+export function setManagerProp<
+	TEntries extends ManagerSetEntries,
+	TProp extends keyof ManagerSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+
+>(
+	/** Manager is mutate if check is not "only" */
+	manager: TEntry["manager"] & { hooks?: THooks },
+	prop: TProp,
+	val: TEntry["val"],
+	{ check = true as TCheck }: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Manager,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetManagerProp">
+> {
+	// castType is used extensively because of https://github.com/microsoft/TypeScript/issues/50652
+	if (check) {
+		switch (prop) {
+			case "state.chain": {
+				castType<TEntries["state.chain"]["val"]>(val)
+				castType<TEntries["state.chain"]["manager"]>(manager)
+
+				const resIsValid = areValidKeys(val, manager)
+				if (resIsValid.isError) return resIsValid satisfies Result<never, MultipleErrors<TEntries["state.chain"]["error"]>>
+				break
+			}
+			case "commands":
+			case "keys":
+			case "shortcuts": {
+				castType<TEntries["commands" | "shortcuts" | "keys"]["val"]>(val)
+				castType<TEntries["commands" | "shortcuts" | "keys"]["manager"]>(manager)
+
+				const managerClone = { ...manager, [prop as any]: val }
+				const res = isValidManager(managerClone)
+				if (res.isError && res.error.code === SHORTCUT_ERROR.INVALID_MANAGER) unreachable()
+				if (res.isError) return res satisfies Result<any, MultipleErrors<typeof SHORTCUT_ERROR.UNKNOWN_COMMAND | ChainError | typeof SHORTCUT_ERROR.INVALID_MANAGER>> as any
+				break
+			}
+			default:
+				break
+		}
+		if (manager?.hooks && "canSetManagerProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks?.canSetManagerProp?.(manager, prop as any, val as any)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+
+	if ((prop as string).includes(".")) {
+		if (prop === "state.chain") {
+			val = cloneChain(val as any) satisfies Manager["state"]["chain"] as any
+		}
+		set(manager, (prop as string).split("."), val)
+	} else {
+		(manager as any)[prop] = val
+	}
+
+	manager.hooks?.onSetManagerProp?.(manager, prop, val)
+
+	return Ok(manager) satisfies Result<Manager, never> as any
+}
+