@oicl-lit/analyzer 0.14.1

package/lib/lit/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/lib/lit/decorators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,MAAM,MAAM,UAAU,GAAG,OAAO,EAAE,CAAC;AAiBnC,eAAO,MAAM,wBAAwB,GACnC,IAAI,UAAU,EACd,WAAW,EAAE,CAAC,SAAS,KACtB,SAAS,IAAI,sBACyC,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,EAAE,CAAC,SAAS;IAC1D,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,cAAc,CAAC;CACxC;AAED,eAAO,MAAM,oBAAoB,GAC/B,IAAI,UAAU,EACd,aAAa,EAAE,CAAC,mBAAmB,kCAIgC,CAAC;AAQtE;;;GAGG;AACH,UAAU,iBAAkB,SAAQ,EAAE,CAAC,SAAS;IAC9C,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,cAAc,CAAC;CACxC;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,IAAI,UAAU,EACd,WAAW,iBAAiB,2CAO7B,CAAC"}

package/lib/lit/decorators.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Returns true if the decorator site is a simple called decorator factory of
+ * the form `@decoratorName()`.
+ *
+ * TODO (justinfagnani): change to looking up decorators by known declarations.
+ */
+const isNamedDecoratorFactory = (ts, decorator, name) => ts.isCallExpression(decorator.expression) &&
+    ts.isIdentifier(decorator.expression.expression) &&
+    decorator.expression.expression.text === name;
+export const isCustomElementDecorator = (ts, decorator) => isNamedDecoratorFactory(ts, decorator, 'customElement');
+export const getPropertyDecorator = (ts, declaration) => ts
+    .getDecorators(declaration)
+    ?.find((d) => isPropertyDecorator(ts, d));
+const isPropertyDecorator = (ts, decorator) => isNamedDecoratorFactory(ts, decorator, 'property');
+/**
+ * Gets the property options object from a `@property()` decorator callsite.
+ *
+ * Only works with an object literal passed as the first argument.
+ */
+export const getPropertyOptions = (ts, decorator) => {
+    const options = decorator.expression.arguments[0];
+    if (options !== undefined && ts.isObjectLiteralExpression(options)) {
+        return options;
+    }
+    return undefined;
+};
+//# sourceMappingURL=decorators.js.map

package/lib/lit/decorators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/lib/lit/decorators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH;;;;;GAKG;AACH,MAAM,uBAAuB,GAAG,CAC9B,EAAc,EACd,SAAuB,EACvB,IAAY,EACyB,EAAE,CACvC,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC,UAAU,CAAC;IACzC,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC;IAChD,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,KAAK,IAAI,CAAC;AAEhD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACtC,EAAc,EACd,SAAuB,EACc,EAAE,CACvC,uBAAuB,CAAC,EAAE,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;AAU1D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,EAAc,EACd,WAAmC,EACnC,EAAE,CACF,EAAE;KACC,aAAa,CAAC,WAAW,CAAC;IAC3B,EAAE,IAAI,CAAC,CAAC,CAAC,EAA0B,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAEtE,MAAM,mBAAmB,GAAG,CAC1B,EAAc,EACd,SAAuB,EACS,EAAE,CAClC,uBAAuB,CAAC,EAAE,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AAUrD;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,EAAc,EACd,SAA4B,EAC5B,EAAE;IACF,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAClD,IAAI,OAAO,KAAK,SAAS,IAAI,EAAE,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,CAAC;QACnE,OAAO,OAAO,CAAC;IACjB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2022 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * @fileoverview\n *\n * Utilities for analyzing ReactiveElement decorators.\n */\n\nimport type ts from 'typescript';\n\nexport type TypeScript = typeof ts;\n\n/**\n * Returns true if the decorator site is a simple called decorator factory of\n * the form `@decoratorName()`.\n *\n * TODO (justinfagnani): change to looking up decorators by known declarations.\n */\nconst isNamedDecoratorFactory = (\n  ts: TypeScript,\n  decorator: ts.Decorator,\n  name: string\n): decorator is CustomElementDecorator =>\n  ts.isCallExpression(decorator.expression) &&\n  ts.isIdentifier(decorator.expression.expression) &&\n  decorator.expression.expression.text === name;\n\nexport const isCustomElementDecorator = (\n  ts: TypeScript,\n  decorator: ts.Decorator\n): decorator is CustomElementDecorator =>\n  isNamedDecoratorFactory(ts, decorator, 'customElement');\n\n/**\n * A narrower type for ts.Decorator that represents the shape of an analyzable\n * `@customElement('x')` callsite.\n */\nexport interface CustomElementDecorator extends ts.Decorator {\n  readonly expression: ts.CallExpression;\n}\n\nexport const getPropertyDecorator = (\n  ts: TypeScript,\n  declaration: ts.PropertyDeclaration\n) =>\n  ts\n    .getDecorators(declaration)\n    ?.find((d): d is PropertyDecorator => isPropertyDecorator(ts, d));\n\nconst isPropertyDecorator = (\n  ts: TypeScript,\n  decorator: ts.Decorator\n): decorator is PropertyDecorator =>\n  isNamedDecoratorFactory(ts, decorator, 'property');\n\n/**\n * A narrower type for ts.Decorator that represents the shape of an analyzable\n * `@customElement('x')` callsite.\n */\ninterface PropertyDecorator extends ts.Decorator {\n  readonly expression: ts.CallExpression;\n}\n\n/**\n * Gets the property options object from a `@property()` decorator callsite.\n *\n * Only works with an object literal passed as the first argument.\n */\nexport const getPropertyOptions = (\n  ts: TypeScript,\n  decorator: PropertyDecorator\n) => {\n  const options = decorator.expression.arguments[0];\n  if (options !== undefined && ts.isObjectLiteralExpression(options)) {\n    return options;\n  }\n  return undefined;\n};\n"]}

package/lib/lit/lit-element.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * @fileoverview
+ *
+ * Utilities for analyzing LitElement (and ReactiveElement) declarations.
+ */
+import type ts from 'typescript';
+import { LitElementDeclaration, AnalyzerInterface } from '../model.js';
+export type TypeScript = typeof ts;
+/**
+ * Gets an analyzer LitElementDeclaration object from a ts.ClassDeclaration
+ * (branded as LitClassDeclaration).
+ */
+export declare const getLitElementDeclaration: (declaration: LitClassDeclaration, analyzer: AnalyzerInterface, isMixinClass?: boolean) => LitElementDeclaration;
+/**
+ * This type identifies a ClassDeclaration as one that inherits from LitElement.
+ *
+ * It lets isLitElement function as a type predicate that returns whether or
+ * not its argument is a LitElement such that when it returns false TypeScript
+ * doesn't infer that the argument is not a ClassDeclaration.
+ */
+export type LitClassDeclaration = ts.ClassDeclaration & {
+    __litBrand: never;
+};
+/**
+ * Returns true if `node` is a ClassLikeDeclaration that extends LitElement.
+ */
+export declare const isLitElementSubclass: (node: ts.Node, analyzer: AnalyzerInterface) => node is LitClassDeclaration;
+/**
+ * Returns the tagname associated with a LitClassDeclaration
+ * @param declaration
+ * @returns
+ */
+export declare const getTagName: (declaration: LitClassDeclaration, analyzer: AnalyzerInterface) => string | undefined;
+//# sourceMappingURL=lit-element.d.ts.map

package/lib/lit/lit-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-element.d.ts","sourceRoot":"","sources":["../../src/lib/lit/lit-element.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAC,qBAAqB,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAYrE,MAAM,MAAM,UAAU,GAAG,OAAO,EAAE,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACnC,aAAa,mBAAmB,EAChC,UAAU,iBAAiB,EAC3B,eAAe,OAAO,KACrB,qBAWF,CAAC;AAkDF;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,EAAE,CAAC,gBAAgB,GAAG;IACtD,UAAU,EAAE,KAAK,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,EAAE,CAAC,IAAI,EACb,UAAU,iBAAiB,KAC1B,IAAI,IAAI,mBAeV,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GACrB,aAAa,mBAAmB,EAChC,UAAU,iBAAiB,uBAkB5B,CAAC"}

package/lib/lit/lit-element.js

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { getClassMembers, getHeritage } from '../javascript/classes.js';
+import { LitElementDeclaration } from '../model.js';
+import { isCustomElementDecorator, } from './decorators.js';
+import { getProperties } from './properties.js';
+import { getJSDocData, getTagName as getCustomElementTagName, } from '../custom-elements/custom-elements.js';
+import { getBaseTypes } from '../utils.js';
+/**
+ * Gets an analyzer LitElementDeclaration object from a ts.ClassDeclaration
+ * (branded as LitClassDeclaration).
+ */
+export const getLitElementDeclaration = (declaration, analyzer, isMixinClass) => {
+    return new LitElementDeclaration({
+        tagname: getTagName(declaration, analyzer),
+        // TODO(kschaaf): support anonymous class expressions when assigned to a const
+        name: declaration.name?.text ?? '',
+        node: declaration,
+        reactiveProperties: getProperties(declaration, analyzer),
+        ...getJSDocData(declaration, analyzer),
+        getHeritage: () => getHeritage(declaration, analyzer, isMixinClass),
+        ...getClassMembers(declaration, analyzer),
+    });
+};
+/**
+ * Returns true if this type represents the actual LitElement class.
+ */
+const _isLitElementClassDeclaration = (t, analyzer) => {
+    // TODO: should we memoize this for performance?
+    const declarations = t.getSymbol()?.getDeclarations();
+    if (declarations?.length !== 1) {
+        return false;
+    }
+    const node = declarations[0];
+    return (_isLitElement(analyzer.typescript, node) ||
+        isLitElementSubclass(node, analyzer));
+};
+/**
+ * Returns true if the given declaration is THE LitElement declaration.
+ *
+ * TODO(kschaaf): consider a less brittle method of detecting canonical
+ * LitElement
+ */
+const _isLitElement = (ts, node) => {
+    return (_isLitElementModule(node.getSourceFile()) &&
+        ts.isClassDeclaration(node) &&
+        node.name?.text === 'LitElement');
+};
+/**
+ * Returns true if the given source file is THE lit-element source file.
+ */
+const _isLitElementModule = (file) => {
+    return (file.fileName.endsWith('/node_modules/lit-element/lit-element.d.ts') ||
+        file.fileName.endsWith('/node_modules/lit-element/development/lit-element.d.ts') ||
+        // Handle case of running analyzer in symlinked monorepo
+        file.fileName.endsWith('/packages/lit-element/lit-element.d.ts') ||
+        file.fileName.endsWith('/packages/lit-element/development/lit-element.d.ts'));
+};
+/**
+ * Returns true if `node` is a ClassLikeDeclaration that extends LitElement.
+ */
+export const isLitElementSubclass = (node, analyzer) => {
+    if (!analyzer.typescript.isClassLike(node)) {
+        return false;
+    }
+    const checker = analyzer.program.getTypeChecker();
+    const type = checker.getTypeAtLocation(node);
+    const baseTypes = getBaseTypes(type);
+    return baseTypes.some((t) => 
+    // Mixins will cause the base types to be an intersection that
+    // includes `LitElement`
+    t.isIntersection()
+        ? t.types.some((t) => _isLitElementClassDeclaration(t, analyzer))
+        : _isLitElementClassDeclaration(t, analyzer));
+};
+/**
+ * Returns the tagname associated with a LitClassDeclaration
+ * @param declaration
+ * @returns
+ */
+export const getTagName = (declaration, analyzer) => {
+    const customElementDecorator = analyzer.typescript
+        .getDecorators(declaration)
+        ?.find((d) => isCustomElementDecorator(analyzer.typescript, d));
+    if (customElementDecorator !== undefined &&
+        customElementDecorator.expression.arguments.length === 1 &&
+        analyzer.typescript.isStringLiteral(customElementDecorator.expression.arguments[0])) {
+        // Get tag from decorator: `@customElement('x-foo')`
+        return customElementDecorator.expression.arguments[0].text;
+    }
+    return getCustomElementTagName(declaration, analyzer);
+};
+//# sourceMappingURL=lit-element.js.map

package/lib/lit/lit-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-element.js","sourceRoot":"","sources":["../../src/lib/lit/lit-element.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2022 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * @fileoverview\n *\n * Utilities for analyzing LitElement (and ReactiveElement) declarations.\n */\n\nimport type ts from 'typescript';\nimport {getClassMembers, getHeritage} from '../javascript/classes.js';\nimport {LitElementDeclaration, AnalyzerInterface} from '../model.js';\nimport {\n  CustomElementDecorator,\n  isCustomElementDecorator,\n} from './decorators.js';\nimport {getProperties} from './properties.js';\nimport {\n  getJSDocData,\n  getTagName as getCustomElementTagName,\n} from '../custom-elements/custom-elements.js';\nimport {getBaseTypes} from '../utils.js';\n\nexport type TypeScript = typeof ts;\n\n/**\n * Gets an analyzer LitElementDeclaration object from a ts.ClassDeclaration\n * (branded as LitClassDeclaration).\n */\nexport const getLitElementDeclaration = (\n  declaration: LitClassDeclaration,\n  analyzer: AnalyzerInterface,\n  isMixinClass?: boolean\n): LitElementDeclaration => {\n  return new LitElementDeclaration({\n    tagname: getTagName(declaration, analyzer),\n    // TODO(kschaaf): support anonymous class expressions when assigned to a const\n    name: declaration.name?.text ?? '',\n    node: declaration,\n    reactiveProperties: getProperties(declaration, analyzer),\n    ...getJSDocData(declaration, analyzer),\n    getHeritage: () => getHeritage(declaration, analyzer, isMixinClass),\n    ...getClassMembers(declaration, analyzer),\n  });\n};\n\n/**\n * Returns true if this type represents the actual LitElement class.\n */\nconst _isLitElementClassDeclaration = (\n  t: ts.BaseType,\n  analyzer: AnalyzerInterface\n) => {\n  // TODO: should we memoize this for performance?\n  const declarations = t.getSymbol()?.getDeclarations();\n  if (declarations?.length !== 1) {\n    return false;\n  }\n  const node = declarations[0];\n  return (\n    _isLitElement(analyzer.typescript, node) ||\n    isLitElementSubclass(node, analyzer)\n  );\n};\n\n/**\n * Returns true if the given declaration is THE LitElement declaration.\n *\n * TODO(kschaaf): consider a less brittle method of detecting canonical\n * LitElement\n */\nconst _isLitElement = (ts: TypeScript, node: ts.Declaration) => {\n  return (\n    _isLitElementModule(node.getSourceFile()) &&\n    ts.isClassDeclaration(node) &&\n    node.name?.text === 'LitElement'\n  );\n};\n\n/**\n * Returns true if the given source file is THE lit-element source file.\n */\nconst _isLitElementModule = (file: ts.SourceFile) => {\n  return (\n    file.fileName.endsWith('/node_modules/lit-element/lit-element.d.ts') ||\n    file.fileName.endsWith(\n      '/node_modules/lit-element/development/lit-element.d.ts'\n    ) ||\n    // Handle case of running analyzer in symlinked monorepo\n    file.fileName.endsWith('/packages/lit-element/lit-element.d.ts') ||\n    file.fileName.endsWith('/packages/lit-element/development/lit-element.d.ts')\n  );\n};\n\n/**\n * This type identifies a ClassDeclaration as one that inherits from LitElement.\n *\n * It lets isLitElement function as a type predicate that returns whether or\n * not its argument is a LitElement such that when it returns false TypeScript\n * doesn't infer that the argument is not a ClassDeclaration.\n */\nexport type LitClassDeclaration = ts.ClassDeclaration & {\n  __litBrand: never;\n};\n\n/**\n * Returns true if `node` is a ClassLikeDeclaration that extends LitElement.\n */\nexport const isLitElementSubclass = (\n  node: ts.Node,\n  analyzer: AnalyzerInterface\n): node is LitClassDeclaration => {\n  if (!analyzer.typescript.isClassLike(node)) {\n    return false;\n  }\n  const checker = analyzer.program.getTypeChecker();\n  const type = checker.getTypeAtLocation(node);\n  const baseTypes = getBaseTypes(type);\n\n  return baseTypes.some((t) =>\n    // Mixins will cause the base types to be an intersection that\n    // includes `LitElement`\n    t.isIntersection()\n      ? t.types.some((t) => _isLitElementClassDeclaration(t, analyzer))\n      : _isLitElementClassDeclaration(t, analyzer)\n  );\n};\n\n/**\n * Returns the tagname associated with a LitClassDeclaration\n * @param declaration\n * @returns\n */\nexport const getTagName = (\n  declaration: LitClassDeclaration,\n  analyzer: AnalyzerInterface\n) => {\n  const customElementDecorator = analyzer.typescript\n    .getDecorators(declaration)\n    ?.find((d): d is CustomElementDecorator =>\n      isCustomElementDecorator(analyzer.typescript, d)\n    );\n  if (\n    customElementDecorator !== undefined &&\n    customElementDecorator.expression.arguments.length === 1 &&\n    analyzer.typescript.isStringLiteral(\n      customElementDecorator.expression.arguments[0]\n    )\n  ) {\n    // Get tag from decorator: `@customElement('x-foo')`\n    return customElementDecorator.expression.arguments[0].text;\n  }\n  return getCustomElementTagName(declaration, analyzer);\n};\n"]}

package/lib/lit/modules.d.ts

@@ -0,0 +1,28 @@
+import type ts from 'typescript';
+type TypeScript = typeof ts;
+/**
+ * Returns true if this node is an import declaration for a module known to
+ * export the Lit html template tag.
+ */
+export declare const isLitHtmlImportDeclaration: (node: ts.Node, ts: TypeScript) => node is ts.ImportDeclaration;
+/**
+ * Returns true if the specifier is known to export the Lit html template tag.
+ *
+ * This can be used in a heuristic to determine if a template is a lit-html
+ * template.
+ */
+export declare const isKnownLitHtmlModuleSpecifier: (specifier: string) => boolean;
+/**
+ * Resolve a common pattern of using the `html` identifier of a lit namespace
+ * import.
+ *
+ * E.g.:
+ *
+ * ```ts
+ * import * as identifier from 'lit';
+ * identifier.html`<p>I am compiled!</p>`;
+ * ```
+ */
+export declare const isResolvedPropertyAccessExpressionLitHtmlNamespace: (node: ts.PropertyAccessExpression, ts: TypeScript, checker: ts.TypeChecker) => boolean;
+export {};
+//# sourceMappingURL=modules.d.ts.map

package/lib/lit/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../src/lib/lit/modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,KAAK,UAAU,GAAG,OAAO,EAAE,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,MAAM,EAAE,CAAC,IAAI,EACb,IAAI,UAAU,KACb,IAAI,IAAI,EAAE,CAAC,iBASb,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,WAAW,MAAM,KAAG,OAMjE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kDAAkD,GAC7D,MAAM,EAAE,CAAC,wBAAwB,EACjC,IAAI,UAAU,EACd,SAAS,EAAE,CAAC,WAAW,KACtB,OAyBF,CAAC"}

package/lib/lit/modules.js

@@ -0,0 +1,62 @@
+/**
+ * Returns true if this node is an import declaration for a module known to
+ * export the Lit html template tag.
+ */
+export const isLitHtmlImportDeclaration = (node, ts) => {
+    if (!ts.isImportDeclaration(node)) {
+        return false;
+    }
+    const specifier = node.moduleSpecifier;
+    if (!ts.isStringLiteral(specifier)) {
+        return false;
+    }
+    return isKnownLitHtmlModuleSpecifier(specifier.text);
+};
+/**
+ * Returns true if the specifier is known to export the Lit html template tag.
+ *
+ * This can be used in a heuristic to determine if a template is a lit-html
+ * template.
+ */
+export const isKnownLitHtmlModuleSpecifier = (specifier) => {
+    return (specifier === 'lit' ||
+        specifier === 'lit-html' ||
+        specifier === 'lit-element');
+};
+/**
+ * Resolve a common pattern of using the `html` identifier of a lit namespace
+ * import.
+ *
+ * E.g.:
+ *
+ * ```ts
+ * import * as identifier from 'lit';
+ * identifier.html`<p>I am compiled!</p>`;
+ * ```
+ */
+export const isResolvedPropertyAccessExpressionLitHtmlNamespace = (node, ts, checker) => {
+    // Ensure propertyAccessExpression ends with `.html`.
+    if (ts.isIdentifier(node.name) && node.name.text !== 'html') {
+        return false;
+    }
+    // Expect a namespace preceding `html`, `<namespace>.html`.
+    if (!ts.isIdentifier(node.expression)) {
+        return false;
+    }
+    // Resolve the namespace if it has been aliased.
+    const symbol = checker.getSymbolAtLocation(node.expression);
+    if (!symbol) {
+        return false;
+    }
+    const namespaceImport = symbol.declarations?.[0];
+    if (!namespaceImport || !ts.isNamespaceImport(namespaceImport)) {
+        return false;
+    }
+    const importDeclaration = namespaceImport.parent.parent;
+    const specifier = importDeclaration.moduleSpecifier;
+    if (!ts.isStringLiteral(specifier)) {
+        return false;
+    }
+    return isKnownLitHtmlModuleSpecifier(specifier.text);
+};
+//# sourceMappingURL=modules.js.map

package/lib/lit/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.js","sourceRoot":"","sources":["../../src/lib/lit/modules.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACxC,IAAa,EACb,EAAc,EACgB,EAAE;IAChC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC;IACvC,IAAI,CAAC,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,6BAA6B,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACvD,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,SAAiB,EAAW,EAAE;IAC1E,OAAO,CACL,SAAS,KAAK,KAAK;QACnB,SAAS,KAAK,UAAU;QACxB,SAAS,KAAK,aAAa,CAC5B,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,kDAAkD,GAAG,CAChE,IAAiC,EACjC,EAAc,EACd,OAAuB,EACd,EAAE;IACX,qDAAqD;IACrD,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC5D,OAAO,KAAK,CAAC;IACf,CAAC;IACD,2DAA2D;IAC3D,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gDAAgD;IAChD,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5D,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,eAAe,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC;IACjD,IAAI,CAAC,eAAe,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,eAAe,CAAC,EAAE,CAAC;QAC/D,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,iBAAiB,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC;IACxD,MAAM,SAAS,GAAG,iBAAiB,CAAC,eAAe,CAAC;IACpD,IAAI,CAAC,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,6BAA6B,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACvD,CAAC,CAAC","sourcesContent":["import type ts from 'typescript';\n\ntype TypeScript = typeof ts;\n\n/**\n * Returns true if this node is an import declaration for a module known to\n * export the Lit html template tag.\n */\nexport const isLitHtmlImportDeclaration = (\n  node: ts.Node,\n  ts: TypeScript\n): node is ts.ImportDeclaration => {\n  if (!ts.isImportDeclaration(node)) {\n    return false;\n  }\n  const specifier = node.moduleSpecifier;\n  if (!ts.isStringLiteral(specifier)) {\n    return false;\n  }\n  return isKnownLitHtmlModuleSpecifier(specifier.text);\n};\n\n/**\n * Returns true if the specifier is known to export the Lit html template tag.\n *\n * This can be used in a heuristic to determine if a template is a lit-html\n * template.\n */\nexport const isKnownLitHtmlModuleSpecifier = (specifier: string): boolean => {\n  return (\n    specifier === 'lit' ||\n    specifier === 'lit-html' ||\n    specifier === 'lit-element'\n  );\n};\n\n/**\n * Resolve a common pattern of using the `html` identifier of a lit namespace\n * import.\n *\n * E.g.:\n *\n * ```ts\n * import * as identifier from 'lit';\n * identifier.html`<p>I am compiled!</p>`;\n * ```\n */\nexport const isResolvedPropertyAccessExpressionLitHtmlNamespace = (\n  node: ts.PropertyAccessExpression,\n  ts: TypeScript,\n  checker: ts.TypeChecker\n): boolean => {\n  // Ensure propertyAccessExpression ends with `.html`.\n  if (ts.isIdentifier(node.name) && node.name.text !== 'html') {\n    return false;\n  }\n  // Expect a namespace preceding `html`, `<namespace>.html`.\n  if (!ts.isIdentifier(node.expression)) {\n    return false;\n  }\n\n  // Resolve the namespace if it has been aliased.\n  const symbol = checker.getSymbolAtLocation(node.expression);\n  if (!symbol) {\n    return false;\n  }\n  const namespaceImport = symbol.declarations?.[0];\n  if (!namespaceImport || !ts.isNamespaceImport(namespaceImport)) {\n    return false;\n  }\n  const importDeclaration = namespaceImport.parent.parent;\n  const specifier = importDeclaration.moduleSpecifier;\n  if (!ts.isStringLiteral(specifier)) {\n    return false;\n  }\n  return isKnownLitHtmlModuleSpecifier(specifier.text);\n};\n"]}

package/lib/lit/properties.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * @fileoverview
+ *
+ * Utilities for analyzing reactive property declarations
+ */
+import type ts from 'typescript';
+import { LitClassDeclaration } from './lit-element.js';
+import { ReactiveProperty, AnalyzerInterface } from '../model.js';
+export type TypeScript = typeof ts;
+export declare const getProperties: (classDeclaration: LitClassDeclaration, analyzer: AnalyzerInterface) => Map<string, ReactiveProperty>;
+/**
+ * Gets the `attribute` property of a property options object as a string.
+ *
+ * The attribute value returned is the value that is used at runtime by
+ * ReactiveElement, not the raw option. If the attribute property option is
+ * not given or is `true`, the lower-cased property name is used. If the
+ * attribute property option is `false`, `undefined` is returned.
+ */
+export declare const getPropertyAttribute: (ts: TypeScript, optionsNode: ts.ObjectLiteralExpression | undefined, propertyName: string) => string | undefined;
+/**
+ * Gets the `type` property of a property options object as a string.
+ *
+ * Note: A string is returned as a convenience so we don't have to compare
+ * the type value against a known set of TS references for String, Number, etc.
+ *
+ * If a non-default converter is used, the types might not mean the same thing,
+ * but we might not be able to realistically support custom converters.
+ */
+export declare const getPropertyType: (ts: TypeScript, obj: ts.ObjectLiteralExpression | undefined) => string | undefined;
+/**
+ * Gets the `reflect` property of a property options object as a boolean.
+ */
+export declare const getPropertyReflect: (ts: TypeScript, obj: ts.ObjectLiteralExpression | undefined) => boolean;
+/**
+ * Gets the `converter` property of a property options object.
+ */
+export declare const getPropertyConverter: (ts: TypeScript, obj: ts.ObjectLiteralExpression | undefined) => ts.PropertyAssignment | undefined;
+//# sourceMappingURL=properties.d.ts.map

package/lib/lit/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../src/lib/lit/properties.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAC,gBAAgB,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAOhE,MAAM,MAAM,UAAU,GAAG,OAAO,EAAE,CAAC;AAEnC,eAAO,MAAM,aAAa,GACxB,kBAAkB,mBAAmB,EACrC,UAAU,iBAAiB,kCA0E5B,CAAC;AAyJF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,IAAI,UAAU,EACd,aAAa,EAAE,CAAC,uBAAuB,GAAG,SAAS,EACnD,cAAc,MAAM,uBAwBrB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAC1B,IAAI,UAAU,EACd,KAAK,EAAE,CAAC,uBAAuB,GAAG,SAAS,uBAU5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,IAAI,UAAU,EACd,KAAK,EAAE,CAAC,uBAAuB,GAAG,SAAS,YAU5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,IAAI,UAAU,EACd,KAAK,EAAE,CAAC,uBAAuB,GAAG,SAAS,sCAM5C,CAAC"}

package/lib/lit/properties.js

@@ -0,0 +1,268 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+import { getTypeForNode } from '../types.js';
+import { getPropertyDecorator, getPropertyOptions } from './decorators.js';
+import { hasStaticModifier } from '../utils.js';
+import { DiagnosticCode } from '../diagnostic-code.js';
+import { createDiagnostic } from '../errors.js';
+export const getProperties = (classDeclaration, analyzer) => {
+    const { typescript: ts } = analyzer;
+    const reactiveProperties = new Map();
+    const undecoratedProperties = new Map();
+    // Filter down to just the property and getter declarations
+    const propertyDeclarations = classDeclaration.members.filter((m) => ts.isPropertyDeclaration(m) || ts.isGetAccessorDeclaration(m));
+    let staticProperties;
+    for (const prop of propertyDeclarations) {
+        if (!ts.isIdentifier(prop.name) && !ts.isPrivateIdentifier(prop.name)) {
+            analyzer.addDiagnostic(createDiagnostic({
+                typescript: ts,
+                node: prop,
+                message: '@lit-labs/analyzer only supports analyzing class properties ' +
+                    'named with plain identifiers, or private class fields. This ' +
+                    'property was ignored: ' +
+                    prop.name.getText(),
+                category: ts.DiagnosticCategory.Warning,
+                code: DiagnosticCode.UNSUPPORTED,
+            }));
+            continue;
+        }
+        const name = prop.name.text;
+        const propertyDecorator = getPropertyDecorator(ts, prop);
+        if (propertyDecorator !== undefined) {
+            // Decorated property; get property options from the decorator and add
+            // them to the reactiveProperties map
+            const options = getPropertyOptions(ts, propertyDecorator);
+            reactiveProperties.set(name, {
+                name,
+                node: prop,
+                optionsNode: options,
+                type: getTypeForNode(prop, analyzer),
+                attribute: getPropertyAttribute(ts, options, name),
+                typeOption: getPropertyType(ts, options),
+                reflect: getPropertyReflect(ts, options),
+                converter: getPropertyConverter(ts, options),
+            });
+        }
+        else if (name === 'properties' && hasStaticModifier(ts, prop)) {
+            // This field has the static properties block (initializer or getter).
+            // Note we will process this after the loop so that the
+            // `undecoratedProperties` map is complete before processing the static
+            // properties block.
+            staticProperties = prop;
+        }
+        else if (!hasStaticModifier(ts, prop)) {
+            // Store the declaration node for any undecorated properties. In a TS
+            // program that happens to use a static properties block along with
+            // the `declare` keyword to type the field, we can use this node to
+            // get/infer the TS type of the field from
+            undecoratedProperties.set(name, prop);
+        }
+    }
+    // Handle static properties block (initializer or getter).
+    if (staticProperties !== undefined) {
+        addPropertiesFromStaticBlock(classDeclaration, staticProperties, undecoratedProperties, reactiveProperties, analyzer);
+    }
+    return reactiveProperties;
+};
+/**
+ * Given a static properties declaration (field or getter), add property
+ * options to the provided `reactiveProperties` map.
+ */
+const addPropertiesFromStaticBlock = (classDeclaration, properties, undecoratedProperties, reactiveProperties, analyzer) => {
+    const { typescript: ts } = analyzer;
+    // Add any constructor initializers to the undecorated properties node map
+    // from which we can infer types from. This is the primary path that JS source
+    // can get their inferred types (in TS, types will come from the undecorated
+    // fields passed in, since you need to declare the field to assign it in the
+    // constructor).
+    addConstructorInitializers(ts, classDeclaration, undecoratedProperties);
+    // Find the object literal from the initializer or getter return value
+    const object = getStaticPropertiesObjectLiteral(properties, analyzer);
+    if (object === undefined) {
+        return;
+    }
+    // Loop over each key/value in the object and add them to the map
+    for (const prop of object.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            const name = prop.name.text;
+            const options = prop.initializer;
+            const nodeForType = undecoratedProperties.get(name);
+            reactiveProperties.set(name, {
+                name,
+                node: prop,
+                optionsNode: options,
+                type: nodeForType !== undefined
+                    ? getTypeForNode(nodeForType, analyzer)
+                    : undefined,
+                attribute: getPropertyAttribute(ts, options, name),
+                typeOption: getPropertyType(ts, options),
+                reflect: getPropertyReflect(ts, options),
+                converter: getPropertyConverter(ts, options),
+            });
+        }
+        else {
+            analyzer.addDiagnostic(createDiagnostic({
+                typescript: ts,
+                node: prop,
+                message: 'Unsupported static properties entry. Expected a string identifier key and object literal value.',
+                code: DiagnosticCode.UNSUPPORTED,
+                category: ts.DiagnosticCategory.Warning,
+            }));
+        }
+    }
+};
+/**
+ * Find the object literal for a static properties block.
+ *
+ * If a ts.PropertyDeclaration, it will look like:
+ *
+ *   static properties = { ... };
+ *
+ * If a ts.GetAccessorDeclaration, it will look like:
+ *
+ *   static get properties() {
+ *     return {... }
+ *   }
+ */
+const getStaticPropertiesObjectLiteral = (properties, analyzer) => {
+    const { typescript: ts } = analyzer;
+    let object = undefined;
+    if (ts.isPropertyDeclaration(properties) &&
+        properties.initializer !== undefined &&
+        ts.isObjectLiteralExpression(properties.initializer)) {
+        // `properties` has a static initializer; get the object from there
+        object = properties.initializer;
+    }
+    else if (ts.isGetAccessorDeclaration(properties)) {
+        // Object was in a static getter: find the object in the return value
+        const statements = properties.body?.statements;
+        const statement = statements?.[statements.length - 1];
+        if (statement !== undefined &&
+            ts.isReturnStatement(statement) &&
+            statement.expression !== undefined &&
+            ts.isObjectLiteralExpression(statement.expression)) {
+            object = statement.expression;
+        }
+    }
+    if (object === undefined) {
+        analyzer.addDiagnostic(createDiagnostic({
+            typescript: ts,
+            node: properties,
+            message: `Unsupported static properties format. Expected an object literal assigned in a static initializer or returned from a static getter.`,
+            code: DiagnosticCode.UNSUPPORTED,
+            category: ts.DiagnosticCategory.Warning,
+        }));
+    }
+    return object;
+};
+/**
+ * Adds any field initializers in the given class's constructor to the provided
+ * map. This will be used for inferring the type of fields in JS programs.
+ */
+const addConstructorInitializers = (ts, classDeclaration, undecoratedProperties) => {
+    const ctor = classDeclaration.forEachChild((node) => ts.isConstructorDeclaration(node) ? node : undefined);
+    if (ctor !== undefined) {
+        ctor.body?.statements.forEach((stmt) => {
+            // Look for initializers in the form of `this.foo = xxxx`
+            if (ts.isExpressionStatement(stmt) &&
+                ts.isBinaryExpression(stmt.expression) &&
+                ts.isPropertyAccessExpression(stmt.expression.left) &&
+                stmt.expression.left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                ts.isIdentifier(stmt.expression.left.name) &&
+                !undecoratedProperties.has(stmt.expression.left.name.text)) {
+                // Add the initializer expression to the map
+                undecoratedProperties.set(
+                // Property name
+                stmt.expression.left.name.text, 
+                // Expression from which we can infer a type
+                stmt.expression.right);
+            }
+        });
+    }
+};
+/**
+ * Gets the `attribute` property of a property options object as a string.
+ *
+ * The attribute value returned is the value that is used at runtime by
+ * ReactiveElement, not the raw option. If the attribute property option is
+ * not given or is `true`, the lower-cased property name is used. If the
+ * attribute property option is `false`, `undefined` is returned.
+ */
+export const getPropertyAttribute = (ts, optionsNode, propertyName) => {
+    if (optionsNode === undefined) {
+        return propertyName.toLowerCase();
+    }
+    const attributeProperty = getObjectProperty(ts, optionsNode, 'attribute');
+    if (attributeProperty === undefined) {
+        return propertyName.toLowerCase();
+    }
+    const { initializer } = attributeProperty;
+    if (ts.isStringLiteral(initializer)) {
+        return initializer.text;
+    }
+    if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
+        return undefined;
+    }
+    if (initializer.kind === ts.SyntaxKind.TrueKeyword ||
+        (ts.isIdentifier(initializer) && initializer.text === 'undefined') ||
+        initializer.kind === ts.SyntaxKind.UndefinedKeyword) {
+        return propertyName.toLowerCase();
+    }
+    return undefined;
+};
+/**
+ * Gets the `type` property of a property options object as a string.
+ *
+ * Note: A string is returned as a convenience so we don't have to compare
+ * the type value against a known set of TS references for String, Number, etc.
+ *
+ * If a non-default converter is used, the types might not mean the same thing,
+ * but we might not be able to realistically support custom converters.
+ */
+export const getPropertyType = (ts, obj) => {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const typeProperty = getObjectProperty(ts, obj, 'type');
+    if (typeProperty !== undefined && ts.isIdentifier(typeProperty.initializer)) {
+        return typeProperty.initializer.text;
+    }
+    return undefined;
+};
+/**
+ * Gets the `reflect` property of a property options object as a boolean.
+ */
+export const getPropertyReflect = (ts, obj) => {
+    if (obj === undefined) {
+        return false;
+    }
+    const reflectProperty = getObjectProperty(ts, obj, 'reflect');
+    if (reflectProperty === undefined) {
+        return false;
+    }
+    return reflectProperty.initializer.kind === ts.SyntaxKind.TrueKeyword;
+};
+/**
+ * Gets the `converter` property of a property options object.
+ */
+export const getPropertyConverter = (ts, obj) => {
+    if (obj === undefined) {
+        return undefined;
+    }
+    return getObjectProperty(ts, obj, 'converter');
+};
+/**
+ * Gets a named property from an object literal expression.
+ *
+ * Only returns a value for `{k: v}` property assignments. Does not work for
+ * shorthand properties (`{k}`), methods, or accessors.
+ */
+const getObjectProperty = (ts, obj, name) => obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+    ts.isIdentifier(p.name) &&
+    p.name.text === name);
+//# sourceMappingURL=properties.js.map