@arcgis/lumina-compiler 4.31.0-next.100

package/dist/jsxToLitHtml/config.d.ts

@@ -0,0 +1,148 @@
+export declare const fragmentName = "Fragment";
+export declare const dynamicHtmlTagName = "DynamicHtmlTag";
+export declare const dynamicSvgTagName = "DynamicSvgTag";
+/**
+ * Using symbols rather than strings for these so that the type system forces us
+ * to handle the dynamic tag name case.
+ */
+export declare const dynamicHtmlSymbol: unique symbol;
+export declare const dynamicSvgSymbol: unique symbol;
+/**
+ * When Stencil encounters a JSX prop like "onArcgisClick", it converts the
+ * first letter of the event name ("ArcgisClick") to lower case, and takes the
+ * rest as is ("arcgisClick").
+ *
+ * But, Preact, React 19 and Lit (Lit JSX in turn) don't do any case
+ * conversion so you have to use "onarcgisClick" instead.
+ *
+ * This means, if you are consuming web component authored in Stencil, it's
+ * JSX typings may wrongly include properties like "onArcgisClick" rather
+ * than "onarcgisClick".
+ *
+ * When consuming Stencil typings in a Lit project, we are creating a mapped
+ * type that fixes the casing difference. But just in case any place slips
+ * through, this flag is used to normalize the casing.
+ */
+export declare const shouldNormalizeCustomElementEventCasing = true;
+/**
+ * Always set these properties as attributes on all elements
+ */
+export declare const alwaysAttributes: Set<string>;
+/**
+ * Always set these properties as attributes on non-custom-elements
+ */
+export declare const nativeAlwaysAttributes: Set<string>;
+/**
+ * These don't exist as a property, only as an attribute
+ */
+export declare const htmlAlwaysAttributes: Record<string, Set<string>>;
+/**
+ * The mappings between native DOM property and the equivalent attribute it
+ * reflects to.
+ *
+ * This list was generated using the ./extractPropertyToAttributeMappings.js
+ * script.
+ *
+ */
+type PropertyToAttributeMappings = {
+    /**
+     * Mappings that are common to all HTML elements
+     */
+    common: ElementPropertyToAttributeMappings;
+    /**
+     * Mappings that are specific to a given HTML element
+     */
+    perElement: Record<string, ElementPropertyToAttributeMappings | undefined>;
+};
+export type ElementPropertyToAttributeMappings = {
+    /**
+     * This list is only used to apply an optional performance optimization.
+     * If it gets out of date or is missing some properties, it's not a big deal.
+     *
+     * This list is used to convert JSX properties with static values to
+     * equivalent attributes.
+     *
+     * Thus instead of `.property=${"1"}` final lit-html looks like `attribute=1`.
+     * Since static attributes are just part of the HTML string and not a special
+     * binding, lit-html doesn't have to waste time diffing them on re-render.
+     */
+    normal?: Record<string, string | undefined>;
+    /**
+     * Unfortunately, for many DOM **properties**, when set to undefined
+     * (`el.autocapitalize = undefined`), rather than removing the attribute, they
+     * set the attribute to an `"undefined"` string. This is never a desirable
+     * outcome. This is the web platform behavior.
+     *
+     * lit-html also has an anti-feature of rendering `undefined` **attribute**
+     * values as `"undefined"` strings (they wanted to mirror the `.setAttribute()`
+     * behavior).
+     *
+     * Thus, the only way to unset such attributes in lit-html is to use attribute
+     * rather than property, and then add `?? nothing` to the attribute value.
+     * `nothing` is a special magic value Lit had to invent to mean
+     * "removeAttribute()"
+     *
+     * Note, we can not use `?? nothing` with property bindings because of
+     * https://github.com/lit/lit/issues/4760
+     */
+    stringified?: Record<string, string | undefined>;
+};
+export declare const propertyToAttributeMappings: PropertyToAttributeMappings;
+export declare const htmlAlwaysBooleanAttributes: Set<string>;
+/**
+ * List of all DOM events settable in JSX. These event names are converted to
+ * lowercase. All others are left as authored as we can't make assumptions about
+ * what was the intended casing.
+ */
+export declare const nativeEvents: Set<string>;
+/**
+ * HTML elements that do not have children and closing tags
+ *
+ * Based on https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+ */
+export declare const voidElements: Set<string>;
+/**
+ * Elements for which the `svg` function needs to be used rather than `html`.
+ *
+ * @example
+ * ```tsx
+ * <svg>
+ *   <circle />
+ * </svg>
+ * ```
+ *
+ * Is converted into:
+ * ```ts
+ * html`<svg>${svg`<circle />`}</svg>`
+ * ```
+ *
+ * (foreign elements in HTML can be self-closing)
+ */
+export declare const svgElements: Set<string>;
+/**
+ * Elements for which the `math` function needs to be used rather than `html`
+ *
+ * @example
+ * ```tsx
+ * <math>
+ *   <mn>6</mn>
+ * </math>
+ * ```
+ *
+ * Is converted into:
+ * ```ts
+ * html`<math>${mathml`<mn>6</mn>`}</math>`
+ * ```
+ *
+ * (foreign elements in HTML can be self-closing)
+ */
+export declare const mathMlElements: Set<string>;
+/**
+ * Although most native elements do not contain dashes inside, there are a
+ * few exceptions. Explicitly declaring a custom element by this name is
+ * forbidden
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#valid_custom_element_names
+ */
+export declare const blockListedCustomElementNames: Set<string>;
+export {};

package/dist/jsxToLitHtml/convertProps.d.ts

@@ -0,0 +1,10 @@
+import ts from "typescript";
+import type { TemplatePart } from "./templateParts";
+import type { JsxContext } from "./types";
+import type { JsxPropType } from "./inferPropType";
+import { type dynamicHtmlSymbol, type dynamicSvgSymbol } from "./config";
+/**
+ * Handle the conversion for each JSX prop type
+ */
+export declare const convertProps: Record<JsxPropType, (context: JsxContext, initializer: ts.JsxAttributeValue | undefined, propName: string, tagName: string | typeof dynamicHtmlSymbol | typeof dynamicSvgSymbol) => TemplatePart[]>;
+export declare function keyInitializerToExpression(initializer: ts.JsxAttributeValue | undefined): ts.Expression;

package/dist/jsxToLitHtml/escapeForTemplateLiteral.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This file is a workaround for a TypeScript bug:
+ * https://github.com/microsoft/TypeScript/issues/59150
+ *
+ * Once that bug is fixed, the code can be simplified like so:
+ * - This file can be removed
+ * - For each place where `escapeBackticks` or `escapeForTemplateLiteral` was
+ *   used and the result was passed as the 1st AND 2nd parameter to one of
+ *   ts.factory.createNoSubstitutionTemplateLiteral,
+ *   ts.factory.createTemplateHead, ts.factory.createTemplateMiddle, or
+ *   ts.factory.createTemplateTail, change those places like so:
+ *   - DO NOT call `escapeBackticks` or `escapeForTemplateLiteral` anymore -
+ *     pass the value as is.
+ *   - DO NOT provide the 2nd parameter to the factory function.
+ * - If `escapeForTemplateLiteral` was used in some other place, it can
+ *   potentially be replaced with a function like this:
+ *   string=>escapeTemplateSubstitution(string).replaceAll('`','\`')
+ *   (where escapeTemplateSubstitution is defined in the current file - move it)
+ *
+ * More details:
+ *
+ * In template literals, even though we *really* only need to escape ${ and
+ * backticks, we are escaping non-ASCII characters too as that improves scanner
+ * performance in JavaScript engines.
+ *
+ * This is what esbuild does (https://esbuild.github.io/api/#charset), what
+ * V8 recommends (https://v8.dev/blog/scanner) and what TypeScript does.
+ *
+ * The code in this file has been copied from TypeScript's code for escaping
+ * template literals (but simplified to remove dead branches and fix eslint
+ * warnings):
+ * https://github.com/microsoft/TypeScript/blob/3163fe7e3898c1f48cd9bc097b96e3426cd2a453/src/compiler/utilities.ts#L5918-L5986
+ *
+ * TypeScript can automatically escape template literals for us, but we opt out
+ * of that as, due to a bug, they also escape new line characters which is not
+ * good as it decreases readability when debugging code.
+ *
+ * TypeScript does not expose the template literal escaping utils so we had
+ * to copy the code here, but modify to not escape new lines.
+ *
+ */
+declare function escapeNonAsciiString(s: string): string;
+export declare const escapeBackticks: typeof escapeNonAsciiString;
+export declare const escapeTemplateSubstitution: (str: string) => string;
+export {};

package/dist/jsxToLitHtml/imports.d.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+import { type JsxContext } from "./types";
+/**
+ * This runs before we know what imports will be needed.
+ *
+ * 1. Go though all import paths and take note of them to inform us later if
+ *    some custom element import still need or need not be added
+ * 2. Take note of all the existing Lit imports. Otherwise, when inserting
+ *    imports, if we see that e.x "html" is not present in the "lit" import, we
+ *    might import it again and fail to check that it might be imported further
+ *    down from "lit-html".
+ */
+export declare function trackExistingImports(context: JsxContext, importDeclaration: ts.ImportDeclaration): ts.ImportDeclaration;
+/**
+ * After we know what imports will be needed, if there already are some imports
+ * from the places we are looking for, augment those import declarations.
+ *
+ * In a step after this, if any imports will still be needed, we will add them.
+ *
+ * @remarks
+ * We don't bother removing `@arcgis/lumina` "h" and "Fragment" imports as those
+ * would be removed by rollup if there are no usages outside of JSX. If
+ * those are explicitly called outside of jsx, Rollup will throw a build time
+ * error (since `@arcgis/lumina` does not actually define h and Fragment but only
+ * declare their typings).
+ */
+export declare function augmentExistingImports(this: JsxContext, node: ts.Statement): ts.Statement;
+/**
+ * For each remaining needed import that is not already included, add an
+ * import declaration
+ */
+export declare function addMissingLitImports(context: JsxContext): ts.ImportDeclaration[];

package/dist/jsxToLitHtml/index.d.ts

@@ -0,0 +1,17 @@
+import type { FileTransformer } from "../publicTypes";
+/**
+ * Let developers author components in JSX for better type checking and developer
+ * experience, but convert JSX to lit-html at build time for better performance.
+ *
+ * This TypeScript transformer converts JSX expressions to lit-html tagged
+ * literals, adding necessary imports in the process
+ *
+ * @remarks
+ * If you wish to explicitly opt-out of JSX to lit-html transform in a given
+ * file, you can do so by specifying a `@jsx` pragma at the top of the file.
+ * For example, to use React JSX in a file, add the following at the top:
+ * ```ts
+ * /** @jsx React.createElement *\/
+ * ```
+ */
+export declare const transformJsxToLitHtml: FileTransformer;

package/dist/jsxToLitHtml/inferPropType.d.ts

@@ -0,0 +1,40 @@
+import ts from "typescript";
+import { dynamicHtmlSymbol, dynamicSvgSymbol } from "./config";
+/**
+ * Check if prop initializer has bindProperty(), bindAttribute(),
+ * bindBooleanAttribute() or bindEvent() call - these explicitly indicate the
+ * prop type.
+ *
+ * @remarks
+ * Not checking for now if function is actually coming from `@arcgis/lumina` - if
+ * this is an issue, can add later
+ */
+export declare function checkExplicitPropType(initializer: ts.JsxAttributeValue | undefined): {
+    readonly propType: JsxPropType;
+    readonly initializer: ts.JsxExpression | undefined;
+} | undefined;
+/**
+ * Decide whether a JSX prop should be converted to property, attribute or event
+ *
+ * Unless there is a good reason to do otherwise, most props are converted into
+ * properties rather than attributes. Reasons:
+ * - For third-party web components, since we are consuming them in JSX, the
+ *   typings will most likely include names of properties not attributes.
+ * - Setting attributes is more bug-prone in lit as `a=${undefined}` is still
+ *   considered truthy (you have to use `a=${nothing}` to unset an attribute)
+ *   - If you want to conditionally display a boolean html attribute, there is
+ *     the `?a=${someBoolean}` syntax.
+ *   - The above two cases add complexity and bugs - properties are much simpler
+ * - Setting property is more performant than setting attribute
+ *
+ * For most HTML attributes, setting the property will reflect to the attribute.
+ * If the third-party web component expects to have the attribute set (for
+ * styling or other reasons), it should reflect the property.
+ * There are also flag functions available (bindAttribute and etc) if you
+ * explicitly want to overwrite the below prop type inference logic.
+ */
+export declare function inferPropType(propName: string, initializer: ts.JsxAttributeValue | undefined, tagName: string | typeof dynamicHtmlSymbol | typeof dynamicSvgSymbol): JsxPropType;
+declare const specialPropsArray: readonly ["class", "style", "ref", "directives", "key"];
+type SpecialProp = (typeof specialPropsArray)[number];
+export type JsxPropType = SpecialProp | "attribute" | "booleanAttribute" | "event" | "property";
+export {};

package/dist/jsxToLitHtml/insertRepeatCall.d.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+import type { JsxContext } from "./types";
+/**
+ * By default, when we see a `key=""` prop, we convert it like this:
+ * ```tsx
+ * // before:
+ * <div key="value" />
+ * // after:
+ * keyed('value', html`<div></div>`);
+ * ```
+ *
+ * However, when mapping over items, if key was provided, using `repeat()` Lit
+ * directive is better for performance as that directive can track when items
+ * change order.
+ *
+ * Without repeat, calling `keyed()` inside of `.map()` is going to be quite
+ * expensive when a single item is added to the top - that will destroy each
+ * element below it and re-create it.
+ *
+ * When key wasn't provided, we assume that the order of items is static or that
+ * modifying the item dom node is cheaper than getting the key and reordering.
+ *
+ * We could have the Stencil to Lit codemod do the `.map()` to `repeat()`
+ * conversion in cases when the map was given an arrow function with a JSX
+ * element with a key, however, some issues with that:
+ *
+ * - For people coming from Stencil or React, it would be confusing to see
+ *   `repeat()` in the code rather than the familiar `.map()`.
+ * - People may not know when to use which, or forget and use `.map()` with a
+ *   `key` inside.
+ * - Since many JSX frameworks handle `key` inside a `.map()` correctly, if in
+ *   the future we move from Lit, it would be nice to have the `key` prop
+ *   already in the source code.
+ *
+ * Thus, instead of doing the conversion in the codemod, I am doing it at build
+ * time in the _JSX to lit-html_ transformer.
+ *
+ * If we were to do this in the codemod, the same code would have to be written
+ * anyway, but here we get ongoing benefit of having code always using the
+ * correct, performant pattern.
+ *
+ * We are only replacing `.map()` with `repeat()` if the map JSX element has a
+ * key prop. There may be some more complex patterns where key was used that we
+ * can't yet detect - those may have worse performance, but the developer can
+ * always call `repeat()` manually.
+ *
+ * @see https://github.com/lit/lit.dev/issues/1351
+ */
+export declare function maybeInsertRepeatCall(context: JsxContext, node: ts.CallExpression): ts.CallExpression;

package/dist/jsxToLitHtml/jsxVisitor.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+import type { TemplatePart } from "./templateParts";
+import type { JsxHost } from "./types";
+import { type JsxContext } from "./types";
+/**
+ * Recursively traverse the entire AST top-down, converting JSX to lit-html.
+ */
+export declare function jsxVisitor<Type extends ts.Node = ts.Node>(context: JsxContext, node: Type): Type;
+export declare function jsxHostToLitExpression(context: JsxContext, jsxHost: JsxHost): ts.Expression;
+export declare const findKeyPropertyIndex: (jsxElement: ts.JsxOpeningElement | ts.JsxSelfClosingElement) => number;
+export declare function jsxExpressionToTemplateParts(context: JsxContext, jsxExpression: ts.JsxExpression): [] | [TemplatePart];

package/dist/jsxToLitHtml/templateParts.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { type JsxContext, type LitTag } from "./types";
+/**
+ * Template part is a convenient intermediate representation for template
+ * literal expressions.
+ *
+ * String template literal parts will be joined together, and expressions will
+ * be put inside of `${}`.
+ */
+export type TemplatePart = ts.Expression | string;
+export type JsxHostTemplateParts = {
+    readonly key: ts.Expression | undefined;
+    readonly parts: TemplatePart[];
+    readonly litTag: LitTag | undefined;
+};
+export declare const isNonEmptyTemplatePart: (part: TemplatePart) => boolean;
+export declare function templatePartsToLitExpression({ key, parts, litTag }: JsxHostTemplateParts, context: JsxContext): ts.Expression;

package/dist/jsxToLitHtml/throwOnImportingExternalized.d.ts

@@ -0,0 +1,10 @@
+import type { JsxContext } from "./types";
+/**
+ * Throw if encountered an explicit non-type-only import for a Calcite component
+ * or some `@arcgis/*` component package - such packages should be externalized,
+ * so there should not be explicit imports from them (otherwise, they would get
+ * bundled in)
+ *
+ * If there are exceptions to this rule, please notify Lumina maintainers.
+ */
+export declare function throwOnImportingExternalized(context: JsxContext): [];

package/dist/jsxToLitHtml/types.d.ts

@@ -0,0 +1,80 @@
+import ts from "typescript";
+import type { ResolvedDependencyComponents } from "../dependencies/discover";
+import type { CompilerContext } from "../context";
+export type JsxContext = {
+    readonly compiler: CompilerContext;
+    /** Source file before the _JSX to lit-html_ transformation */
+    readonly sourceFile: ts.SourceFile;
+    readonly transformationContext: ts.TransformationContext;
+    /**
+     * All encountered native HTML elements and custom-elements along with a
+     * reference to a TypeScript JSX node where first occurrence was. You can use
+     * the TypeScript node to find the location where component was declared and
+     * thus inform what import paths need to be added in the current file.
+     *
+     * If you successfully resolved some element from this map, then please
+     * remove it from the map to not confuse any following resolvers.
+     */
+    readonly customElementsToImport: Set<string>;
+    /**
+     * Existing imported modules.
+     *
+     * If original specifier was for an external package, this will include the
+     * specifier as is.
+     *
+     * If original specifier was to a relative file, the path will be resolved
+     * to an absolute path, but without a file extension.
+     *
+     * Can be used to inform what custom elements are already imported
+     */
+    readonly existingImportedModules: Set<string>;
+    /**
+     * A set of absolute paths to modules in the current package from which the
+     * current file imported capitalized identifiers (capitalized identifier is
+     * often a functional component, though not always)
+     */
+    readonly importedFunctionComponentsFromModules: Set<string>;
+    readonly existingLitImports: Set<JsxImportName>;
+    readonly neededImports: Set<JsxImportName>;
+    readonly externalComponents: ResolvedDependencyComponents["components"];
+    readonly localComponents: ResolvedDependencyComponents["components"];
+};
+/**
+ * There are more lit directives, but these are the ones that can be inserted
+ * during the _JSX to lit-html_ conversion
+ */
+type LitDirective = "keyed" | "ref" | "repeat";
+/**
+ * Funny that lit called the "dynamic html" version of "html" as "staticHtml"
+ */
+export declare const staticHtmlTag = "staticHtml";
+export declare const staticSvgTag = "staticSvg";
+export declare const htmlTag = "html";
+export declare const svgTag = "svg";
+export declare const cssTag = "css";
+export declare const mathMlTag = "mathml";
+declare const litTagsArray: readonly ["css", "html", "mathml", "staticHtml", "staticSvg", "svg"];
+export declare const litTags: Set<"css" | "html" | "mathml" | "staticHtml" | "staticSvg" | "svg">;
+export type LitTag = (typeof litTagsArray)[number];
+type LuminaJsxImportName = "safeClassMap" | "safeStyleMap";
+type LitMagicValue = "nothing";
+export type JsxImportName = LitDirective | LitMagicValue | LitTag | LuminaJsxImportName;
+export type JsxHost = ts.JsxElement | ts.JsxFragment | ts.JsxSelfClosingElement;
+export declare const isJsxHost: (node: ts.Node) => node is JsxHost;
+/**
+ * "web-types.json" has TypeScript definitions, but those are in a package that
+ * has a bunch of Vue dependencies, which we don't want. Opened an issue:
+ * https://github.com/JetBrains/web-types/issues/83
+ */
+export type WebTypesJson = {
+    readonly contributions?: {
+        readonly html?: {
+            readonly elements?: readonly WebTypesElement[];
+            readonly tags?: readonly WebTypesElement[];
+        };
+    };
+};
+type WebTypesElement = {
+    readonly name: string;
+};
+export {};

package/dist/jsxToLitHtml/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const jsxToLitHtmlPluginName = "@arcgis/lumina:jsxToLitHtml";
+/**
+ * Trim whitespace in the jsx text where safe, without breaking cases like this:
+ * ```tsx
+ * <p>Format: {text}</p>
+ * ```
+ *
+ * This does not handle some cases if they are already handled by Prettier
+ * (like trailing whitespace on a line, or two consecutive non-indent white-spaces)
+ */
+export declare function safeTrimText(text: string): string;
+export declare const escapeForTemplateLiteral: (string: string) => string;
+export declare const shouldQuoteAttributeValue: (value: string) => boolean;
+export declare const escapeForHtml: (string: string) => string;

package/dist/jsxToLitHtml/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/manifests/complexTypes/addComponentMetadata.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@custom-elements-manifest/analyzer";
+import type { ClassMember } from "custom-elements-manifest";
+import type { CompilerContext } from "../../context";
+export declare function addComponentMetadata(context: CompilerContext): Plugin;
+export declare const isPublic: (member: ClassMember) => boolean;

package/dist/manifests/complexTypes/addMethodMetadata.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "@custom-elements-manifest/analyzer";
+import type { CompilerContext } from "../../context";
+/**
+ * Extract extra metadata about methods to match what Stencil's docs.json contains
+ */
+export declare function addMethodMetadata(context: CompilerContext): Plugin;

package/dist/manifests/complexTypes/addPropMetadata.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "@custom-elements-manifest/analyzer";
+import type { ExtendedManifestEvent } from "./types";
+import type { CompilerContext } from "../../context";
+export type PropMetadataContext = (Pick<ExtendedManifestEvent, "bubbles" | "cancelable" | "composed"> & {
+    eventName: string;
+})[];
+/** Resolve complex types and their references */
+export declare function addPropMetadata(context: CompilerContext): Plugin;

package/dist/manifests/complexTypes/docsUtils.d.ts

@@ -0,0 +1,18 @@
+import type { ExtendedManifestField } from "./types";
+import ts from "typescript";
+export declare function symbolToDocs(checker: ts.TypeChecker, symbol: ts.Signature | ts.Symbol): Pick<ExtendedManifestField, "description" | "docsTags">;
+export declare const notPublicJsDocTag = "notPublic";
+export declare const internalJsDocTag = "internal";
+export declare const findDecorator: ({ modifiers }: {
+    modifiers?: readonly ts.ModifierLike[];
+}, name: string) => ts.CallExpression | undefined;
+/**
+ * More strict than CEM's default:
+ * https://github.com/open-wc/custom-elements-manifest/blob/94650b64f992c216ff770ac9e398db7c4491c949/packages/analyzer/src/features/analyse-phase/creators/handlers.js#L289-L294
+ */
+export declare const isDefaultValueDocumentationEligible: (initializer: ts.Expression | undefined) => initializer is ts.Expression;
+/**
+ * Remove null and undefined from resolved type string to keep the docs cleaner.
+ * All non-required properties could be null or undefined.
+ */
+export declare function stripNullables(type: string): string;

package/dist/manifests/complexTypes/event.d.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+import type { ComponentCompilerEventType } from "./types";
+import type { ContextDirectories } from "../../context/types";
+/**
+ * If property is an event emitter, extract event payload type and event name.
+ * Even name is derived by converting property name to kebab-case.
+ */
+export declare function extractEventType(checker: ts.TypeChecker, propertyDeclaration: ts.PropertyDeclaration, resolvedType: ts.Type, sourceFile: ts.SourceFile, dirs: ContextDirectories): ComponentCompilerEventType | undefined;
+export declare function extractBoolean(objectLiteral: ts.ObjectLiteralExpression, name: string): boolean | undefined;

package/dist/manifests/complexTypes/getComplexPropertyType.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+import type { ComponentCompilerEventType, ComponentCompilerPropertyComplexType } from "./types";
+import type { JsonDocsValue } from "@stencil/core/internal";
+import type { ContextDirectories } from "../../context/types";
+/**
+ * @remarks
+ * Based on Stencil's getComplexType function:
+ * https://github.com/ionic-team/stencil/blob/b40ebb937869aa16f9adc672129639167406cd07/src/compiler/transformers/decorators-to-static/prop-decorator.ts#L165
+ */
+export declare const getComplexPropertyType: (checker: ts.TypeChecker, dirs: ContextDirectories, decoratedNode: ts.AccessorDeclaration | ts.PropertyDeclaration, typeContainerNode: ts.AccessorDeclaration | ts.PropertyDeclaration) => ComponentCompilerEventType | ComponentCompilerPropertyComplexType | undefined;
+export declare const hasLiteralTypeValue: (typeValues: JsonDocsValue[]) => boolean;