public register()

in packages/web-components/fast-foundation/src/design-system/design-system.ts [237:321]
74 lines of code
13 McCabe index (conditional complexity)

    public register(...registrations: any[]): DesignSystem {
        const container = this.container;
        const elementDefinitionEntries: ElementDefinitionEntry[] = [];
        const disambiguate = this.disambiguate;
        const shadowRootMode = this.shadowRootMode;
        const context: DesignSystemRegistrationContext = {
            elementPrefix: this.prefix,
            tryDefineElement(
                params: string | ElementDefinitionParams,
                elementDefinitionType?: Constructable,
                elementDefinitionCallback?: ElementDefinitionCallback
            ) {
                const extractedParams = extractTryDefineElementParams(
                    params,
                    elementDefinitionType,
                    elementDefinitionCallback
                );
                const { name, callback, baseClass } = extractedParams;
                let { type } = extractedParams;
                let elementName: string | null = name;

                let typeFoundByName = elementTypesByTag.get(elementName);
                let needsDefine = true;

                while (typeFoundByName) {
                    const result = disambiguate(elementName, type, typeFoundByName);

                    switch (result) {
                        case ElementDisambiguation.ignoreDuplicate:
                            return;
                        case ElementDisambiguation.definitionCallbackOnly:
                            needsDefine = false;
                            typeFoundByName = void 0;
                            break;
                        default:
                            elementName = result as string;
                            typeFoundByName = elementTypesByTag.get(elementName);
                            break;
                    }
                }

                if (needsDefine) {
                    if (elementTagsByType.has(type) || type === FoundationElement) {
                        type = class extends type {};
                    }
                    elementTypesByTag.set(elementName, type);
                    elementTagsByType.set(type, elementName);
                    if (baseClass) {
                        elementTagsByType.set(baseClass, elementName!);
                    }
                }

                elementDefinitionEntries.push(
                    new ElementDefinitionEntry(
                        container,
                        elementName,
                        type,
                        shadowRootMode,
                        callback,
                        needsDefine
                    )
                );
            },
        };

        if (!this.designTokensInitialized) {
            this.designTokensInitialized = true;

            if (this.designTokenRoot !== null) {
                DesignToken.registerRoot(this.designTokenRoot);
            }
        }

        container.registerWithContext(context, ...registrations);

        for (const entry of elementDefinitionEntries) {
            entry.callback(entry);

            if (entry.willDefine && entry.definition !== null) {
                entry.definition.define();
            }
        }

        return this;
    }