@flamework-experimental/core 2.0.0-alpha.0

package/out/modding.luau

@@ -0,0 +1,66 @@
+-- Compiled with roblox-ts v3.0.0
+local Modding = {}
+do
+	local _container = Modding
+	--[[
+		*
+		     * This function is able to utilize Flamework's user macros to generate and inspect types.
+		     * This function supports all values natively supported by Flamework's user macros.
+		     *
+		     * For example, if you want to retrieve the properties of an instance, you could write code like this:
+		     * ```ts
+		     * // Returns an array of all keys part of the union.
+		     * const basePartKeys = Modding.inspect<InstancePropertyNames<BasePart>[]>();
+		     * ```
+		     *
+		     * @metadata macro
+		     
+	]]
+	local function inspect(value)
+		local _value = value
+		assert(_value)
+		return value
+	end
+	_container.inspect = inspect
+	--[[
+		*
+		     * This type emits runtime equivalents of types, such as generating strings from string literal types.
+		     *
+		     * You are able to generate most TS types, including objects and tuples which will generate equivalent objects at runtime.
+		     * Additionally, you can generate unions by using `Array<T>`, which will generate an array where each constituent of `T` is its own element.
+		     *
+		     * This type is primarily used to mark a user macro parameter as metadata, and is not necessary if you use other macro types.
+		     
+	]]
+	--[[
+		*
+		     * Creates an injectable type that can be used to modify dependency injection behavior.
+		     
+	]]
+	--[[
+		*
+		     * An internal type for intrinsic user macro metadata.
+		     *
+		     * @hidden
+		     
+	]]
+	--[[
+		*
+		     * This namespace contains types and metadata related to the current macro's callsite.
+		     
+	]]
+	--[[
+		*
+		     * This namespace contains types that allow you to perform functions or fetch metadata about specific types.
+		     
+	]]
+	--[[
+		*
+		     * Information about an injected dependency.
+		     
+	]]
+	-- This is used so that nested `Modding.Injectable` calls are treated correctly.
+end
+return {
+	Modding = Modding,
+}

package/out/module/defaultModule.d.ts

@@ -0,0 +1,5 @@
+import type { Module } from "./module";
+export declare function getDefaultModule(): Module | undefined;
+export declare function setDefaultModule(module: Module): void;
+/** Releases the default if `module` is it; a module that never was the default changes nothing. */
+export declare function clearDefaultModule(module: Module): void;

package/out/module/defaultModule.luau

@@ -0,0 +1,28 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * The module `Dependency<T>()` resolves against.
+	 *
+	 * The first root module ignited in a realm claims it, and igniting with `{ default: true }` replaces
+	 * it. Extinguishing the default releases it, so the next root ignited becomes the default again --
+	 * which is what lets a test ignite and extinguish a module per case without leaking one into the next.
+	 
+]]
+local defaultModule
+local function getDefaultModule()
+	return defaultModule
+end
+local function setDefaultModule(module)
+	defaultModule = module
+end
+--* Releases the default if `module` is it; a module that never was the default changes nothing. 
+local function clearDefaultModule(module)
+	if defaultModule == module then
+		defaultModule = nil
+	end
+end
+return {
+	getDefaultModule = getDefaultModule,
+	setDefaultModule = setDefaultModule,
+	clearDefaultModule = clearDefaultModule,
+}

package/out/module/module.d.ts

@@ -0,0 +1,78 @@
+import { Modding } from "../modding";
+import type { Constructor } from "../utility/constructors";
+import type { Destructor, ExtractSingleCallback } from "../utility/types";
+import type { IgniteOptions, ModuleState } from "./moduleDefinition";
+/** What a lookup through a module and its imports found: where, and which class when it is a class provider. */
+export interface ProviderLookup {
+    module: Module;
+    classValue?: object;
+}
+interface InternalModule {
+}
+export interface Module extends InternalModule {
+    /** The name the module reports itself by: set on the builder, or generated from where it was created. */
+    readonly debugName: string;
+    /**
+     * Whether ignition has completed and {@link extinguish} has not been called. What a module has
+     * to be before another can import it.
+     */
+    isIgnited: () => boolean;
+    /**
+     * This function manually fetches a dependency from this module, as opposed to dependency injection.
+     *
+     * @metadata macro
+     */
+    resolveDependency: <T = unknown>(info?: string | Modding.Target.DependencyConcise<T>) => T;
+    /**
+     * Terminates this module.
+     *
+     * This runs the plugins' `onExtinguished` hooks.
+     */
+    extinguish: () => void;
+    /**
+     * Registers a listener for the specified lifecycle event.
+     * You can optionally provide a function as a shorthand for lifecycle events with a single method.
+     *
+     * This function returns a destructor that can be used to disconnect the lifecycle event.
+     *
+     * @param value The object that implements the lifecycle event.
+     * @metadata macro
+     */
+    listen<T>(this: void, value: T, meta?: Modding.Target.Id<T>): Destructor;
+    /**
+     * Registers a listener for the specified lifecycle event, using a shorthand function.
+     * This overload can only be used on lifecycle events that have a single method.
+     *
+     * This function returns a destructor that can be used to disconnect the lifecycle event.
+     *
+     * @param value A shorthand function for the lifecycle event.
+     * @metadata macro
+     */
+    listen<T>(this: void, value: ExtractSingleCallback<T>, id?: Modding.Target.Id<T>, name?: Modding.Emit<keyof T>): Destructor;
+    /**
+     * Constructs a class through this module's dependency injection without registering it as a
+     * provider, and attaches it to any lifecycle events it implements.
+     *
+     * The instance is owned by this module: it is released when {@link extinguish} runs, or earlier
+     * via {@link removeClassInstance}.
+     */
+    createClassInstance: <T extends object>(constructor: Constructor<T>, config?: InstanceCreationConfig) => T;
+    /**
+     * Detaches an instance created by {@link createClassInstance} from its lifecycle events.
+     */
+    removeClassInstance: (instance: object) => void;
+    /**
+     * Whether {@link extinguish} has been called on this module.
+     */
+    isExtinguished: () => boolean;
+}
+interface InstanceCreationConfig {
+    /**
+     * When specified, this allows you to override dependency resolution.
+     *
+     * If this function returns `undefined`, then dependency resolution will fallback to the module's resolution.
+     */
+    overrideDependency?: (info: Modding.DependencyInfo) => unknown;
+}
+export declare function createModuleInstantiation(state: ModuleState, options?: IgniteOptions): Module;
+export {};