@pikku/inspector 0.12.110 → 0.12.111

package/dist/utils/find-unused-functions.js

@@ -0,0 +1,132 @@
+/** Scenarios and their steps are run by the scenario runner, never wired or called. */
+const RUN_BY_SCENARIOS = new Set([
+    'pikkuScenario',
+    'pikkuScenarioStep',
+    'pikkuPlatformScenarioStep',
+    'pikkuAddonScenarioStep',
+]);
+/** Sections that describe functions rather than use them. */
+const NOT_USES = new Set([
+    'functions',
+    'schemas',
+    'schemaLookup',
+    'serviceAggregation',
+    'nodes',
+    'resolvedIOTypes',
+    'addonFunctions',
+    'remoteAddonFunctions',
+    'program',
+    'stats',
+]);
+/** Keys under which a wiring names the function it runs. */
+const FUNCTION_KEYS = new Set(['pikkuFuncId', 'rpcName', 'receive']);
+const collectUses = (value, into, seen, key) => {
+    if (typeof value === 'string') {
+        if (key && FUNCTION_KEYS.has(key))
+            into.add(value);
+        return;
+    }
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    if (value instanceof Map) {
+        for (const child of value.values())
+            collectUses(child, into, seen);
+        return;
+    }
+    if (value instanceof Set)
+        return;
+    if (Array.isArray(value)) {
+        for (const child of value) {
+            if (key === 'tools' && typeof child === 'string')
+                into.add(child);
+            else
+                collectUses(child, into, seen);
+        }
+        return;
+    }
+    // Only plain data: the TypeScript inspector's state also holds compiler
+    // objects (types, nodes) whose getters throw when read.
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+        return;
+    for (const [childKey, child] of Object.entries(value)) {
+        collectUses(child, into, seen, childKey);
+    }
+};
+/**
+ * The app's own functions that nothing uses: not wired to any transport, not
+ * exposed, published or offered to MCP, and not called by name. Addon
+ * functions are never judged: an addon project's own functions are all addon
+ * functions, and a consumer's state holds no addon functions in
+ * `functions.meta`. Neither are scenarios, inline wiring functions or disabled
+ * functions. A workflow is a function like any other: it is used when it is
+ * wired, exposed, or started by a literal name — `rpc.startWorkflow`,
+ * `workflowService.startWorkflow` / `runToCompletion`, `rpc.invoke`, another
+ * workflow's step, or the generated client helpers.
+ */
+export const findUnusedFunctions = (state, { addon = false } = {}) => {
+    if (addon)
+        return [];
+    const uses = new Set(state.serviceAggregation.usedFunctions);
+    for (const name of state.rpc.invokedFunctions)
+        uses.add(name);
+    for (const id of Object.values(state.rpc.exposedMeta))
+        uses.add(id);
+    const seen = new WeakSet();
+    for (const [section, value] of Object.entries(state)) {
+        if (NOT_USES.has(section) || section === 'rpc' || section === 'workflows')
+            continue;
+        collectUses(value, uses, seen);
+    }
+    // A workflow's own meta and graph name the workflow itself; only what its
+    // steps call counts as a use.
+    const { meta: workflowsMeta, graphMeta } = state.workflows;
+    for (const entries of [workflowsMeta, graphMeta]) {
+        for (const [workflowName, entry] of Object.entries(entries ?? {})) {
+            const calls = new Set();
+            collectUses(entry, calls, seen);
+            calls.delete(workflowName);
+            if (entry?.pikkuFuncId)
+                calls.delete(entry.pikkuFuncId);
+            for (const call of calls)
+                uses.add(call);
+        }
+    }
+    // Workflows started by name: client helpers, `startWorkflow` and
+    // `runToCompletion` calls, and each function's own `rpc.startWorkflow`.
+    const startedWorkflows = new Set(state.workflows.invokedWorkflows);
+    for (const meta of Object.values(state.functions.meta)) {
+        for (const name of meta.startsWorkflows ?? [])
+            startedWorkflows.add(name);
+    }
+    for (const workflowName of startedWorkflows)
+        uses.add(workflowName);
+    // A workflow named by its workflow name, by any of the above or by
+    // `rpc.invoke` and step calls, uses the function behind it.
+    for (const [workflowName, entry] of Object.entries(workflowsMeta)) {
+        if (uses.has(workflowName) && entry?.pikkuFuncId)
+            uses.add(entry.pikkuFuncId);
+    }
+    const unused = [];
+    for (const [pikkuFuncId, meta] of Object.entries(state.functions.meta)) {
+        if (meta.functionType !== 'user')
+            continue;
+        if (meta.funcWrapper && RUN_BY_SCENARIOS.has(meta.funcWrapper))
+            continue;
+        if (meta.expose || meta.remote || meta.mcp)
+            continue;
+        // A generated scaffold is rewritten on every run, so `disabled` cannot be
+        // added to it; what it leaves unwired it leaves for the project to wire.
+        if (meta.sourceFile?.endsWith('.gen.ts'))
+            continue;
+        if (uses.has(pikkuFuncId) || (meta.name && uses.has(meta.name)))
+            continue;
+        unused.push({
+            pikkuFuncId,
+            ...(meta.name ? { name: meta.name } : {}),
+            ...(meta.sourceFile ? { sourceFile: meta.sourceFile } : {}),
+        });
+    }
+    return unused;
+};

package/dist/utils/get-property-value.js

@@ -202,7 +202,10 @@ export const getCommonWireMetaData = (obj, wiringType, wiringName, logger, check
         if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
             const propName = prop.name.text;
             if (propName === 'disabled' &&
-                prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                    ((ts.isStringLiteral(prop.initializer) ||
+                        ts.isNoSubstitutionTemplateLiteral(prop.initializer)) &&
+                        prop.initializer.text !== ''))) {
                 metadata.disabled = true;
             }
             else if (propName === 'title') {

package/dist/utils/load-addon-functions-meta.js

@@ -1,9 +1,10 @@
 import { existsSync } from 'fs';
 import { readFile, readdir } from 'fs/promises';
-import { join, dirname, parse, relative } from 'path';
+import { join, dirname, relative } from 'path';
 import { addonResolutionDirs, createAddonResolver, } from './addon-resolution.js';
 import { ErrorCode } from '../error-codes.js';
 import { checkLockedSdk } from './remote-addon-sdk.js';
+import { declaredAddonNames, findInstalledPackageDir, readAddonDependencies, } from './addon-dependencies.js';
 const isHTTPRouteConfig = (value) => typeof value === 'object' &&
     value !== null &&
     'method' in value &&
@@ -92,24 +93,6 @@ const resolveAddonMeta = (require, packageName, baseName) => {
     }
     return null;
 };
-const findInstalledPackageDir = (dirs, packageName) => {
-    for (const start of dirs) {
-        const root = parse(start).root;
-        let dir = start;
-        while (dir) {
-            const candidate = join(dir, 'node_modules', packageName);
-            if (existsSync(join(candidate, 'package.json')))
-                return candidate;
-            if (dir === root)
-                break;
-            const parent = dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    return null;
-};
 export const describeMissingAddonMeta = (namespace, packageName, dirs, declFile) => {
     const caller = declFile
         ? relative(dirs[dirs.length - 1], declFile) || declFile
@@ -183,27 +166,12 @@ export const namespaceAddonWebhookSources = (sources, namespace) => {
  * package's function metadata so that wiring handlers (channels, HTTP routes,
  * schedules, etc.) can look up addon function types during the routes sweep.
  */
-const loadScreensManifest = async (require, packageName) => {
+const loadStudioMeta = async (require, packageName) => {
     const path = resolveAddonMeta(require, packageName, 'screens/pikku-screens-meta');
     if (!path)
         return null;
     return JSON.parse(await readFile(path, 'utf-8'));
 };
-const readAddonNeeds = async (dirs, packageName) => {
-    const dir = findInstalledPackageDir(dirs, packageName);
-    if (!dir)
-        return [];
-    try {
-        const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf-8'));
-        const uses = pkg?.pikku?.uses;
-        return Array.isArray(uses)
-            ? uses.filter((u) => typeof u === 'string')
-            : [];
-    }
-    catch {
-        return [];
-    }
-};
 const isContributorRef = (value) => !!value &&
     typeof value === 'object' &&
     typeof value.module === 'string' &&
@@ -260,6 +228,36 @@ const loadRemoteAddonSdkMeta = async (state, namespace, packageName, range) => {
         return;
     (state.remoteAddonFunctions ??= {})[namespace] = JSON.parse(await readFile(metaPath, 'utf-8'));
 };
+/**
+ * Reads the addons a wired package says it calls (`pikku.uses` in its
+ * package.json) onto its declaration, and reports each one this wiring leaves
+ * unmapped. Whether a mapping points at the right package, and whether the
+ * wiring maps a name the package never declared, is `validateAddonUses`' call
+ * once every wiring is known.
+ */
+const recordDeclaredUses = (logger, namespace, decl, dirs) => {
+    const packageDir = findInstalledPackageDir(dirs, decl.package);
+    if (!packageDir)
+        return;
+    const declared = readAddonDependencies(packageDir);
+    if (declared.form === 'none')
+        return;
+    if (declared.form === 'map') {
+        for (const message of declared.invalid) {
+            logger.critical(ErrorCode.ADDON_DEPENDENCY_INVALID, `${decl.package} (wired as '${namespace}'): ${message}`);
+        }
+        decl.dependencies = declared.dependencies;
+    }
+    decl.declaredUses = declaredAddonNames(declared);
+    for (const needed of decl.declaredUses) {
+        if (decl.uses?.[needed])
+            continue;
+        const dependency = decl.dependencies?.find((d) => d.alias === needed);
+        logger.critical(ErrorCode.ADDON_NEEDS_NOT_MAPPED, dependency
+            ? `${decl.package} calls ${dependency.package}@${dependency.range} as '${needed}', but wireAddon('${namespace}') does not map it. Wire ${dependency.package} and add uses: { '${needed}': '<name>' } to this wireAddon.`
+            : `${decl.package} needs ${needed}, but wireAddon('${namespace}') does not map it. Wire ${needed} and add uses: { '${needed}': '<name>' } to this wireAddon.`);
+    }
+};
 export async function loadAddonFunctionsMeta(logger, state) {
     const { wireAddonDeclarations } = state.rpc;
     if (wireAddonDeclarations.size === 0)
@@ -287,16 +285,12 @@ export async function loadAddonFunctionsMeta(logger, state) {
             catch (error) {
                 logger.error(`wireAddon('${namespace}'): ${error instanceof Error ? error.message : error}`);
             }
-            for (const needed of await readAddonNeeds(dirs, decl.package)) {
-                if (!decl.uses?.[needed]) {
-                    logger.critical(ErrorCode.ADDON_NEEDS_NOT_MAPPED, `${decl.package} needs ${needed}, but wireAddon('${namespace}') does not map it. Wire ${needed} and add uses: { '${needed}': '<name>' } to this wireAddon.`);
-                }
-            }
+            recordDeclaredUses(logger, namespace, decl, dirs);
             if (decl.ui) {
                 let manifest;
                 let unreadable = false;
                 try {
-                    manifest = await loadScreensManifest(require, decl.package);
+                    manifest = await loadStudioMeta(require, decl.package);
                 }
                 catch (e) {
                     logger.critical(ErrorCode.ADDON_UI_HAS_NO_SCREENS, `wireAddon('${namespace}') sets ui: true, but the screens manifest of ${decl.package} could not be read: ${e instanceof Error ? e.message : e}`);
@@ -306,11 +300,11 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     // reported above; the addon's functions and scopes still load
                 }
                 else if (!manifest || manifest.screens.length === 0) {
-                    logger.critical(ErrorCode.ADDON_UI_HAS_NO_SCREENS, `wireAddon('${namespace}') sets ui: true, but ${decl.package} declares no screens. Add a defineScreens call to the package, or drop ui.`);
+                    logger.critical(ErrorCode.ADDON_UI_HAS_NO_SCREENS, `wireAddon('${namespace}') sets ui: true, but ${decl.package} declares no screens. Add a pikkuStudio call to the package, or drop ui.`);
                 }
                 else {
                     ;
-                    (state.addonScreens ??= {})[namespace] = {
+                    (state.addonStudio ??= {})[namespace] = {
                         ...manifest,
                         scopes: [
                             ...new Set([...(manifest.scopes ?? []), ...(decl.scopes ?? [])]),

package/dist/utils/post-process.js

@@ -239,8 +239,9 @@ export function aggregateRequiredServices(state) {
     // nothing, so they are found by id: the route accepts into the queue through
     // incomingWebhookService and the worker records attempts through it.
     const hasWebhookSources = Object.values(state.triggers?.webhookSourceMeta ?? {}).some(({ method, route }) => state.functions.meta[`http:${method}:${route}`] !== undefined);
-    if (hasWebhookSources ||
-        state.functions.meta['queue:pikku-incoming-webhooks'] !== undefined) {
+    const wiresIncomingWebhooks = hasWebhookSources ||
+        state.functions.meta['queue:pikku-incoming-webhooks'] !== undefined;
+    if (wiresIncomingWebhooks) {
         requiredServices.add('incomingWebhookService');
         requiredServices.add('queueService');
     }
@@ -333,6 +334,12 @@ export function aggregateRequiredServices(state) {
             addonFnServices.set(`${namespace}:${id}`, meta?.services?.services);
         }
     }
+    // An addon forwarding `incomingWebhookService` (pikku-admin lists receipts)
+    // reads it when the app has one; it never makes the app keep receipts. Only
+    // the app's own webhook sources do, so only they bring in the service and its
+    // tables — otherwise an app with no webhook wired fails to boot on a
+    // `webhook_receipt` table nothing writes to.
+    const readOnlyIfPresent = (service) => service === 'incomingWebhookService' && !wiresIncomingWebhooks;
     const parentDeclared = state.addonRequiredParentServices ?? [];
     const parentDeclaredSet = new Set(parentDeclared);
     const defaultServices = new Set([
@@ -354,6 +361,9 @@ export function aggregateRequiredServices(state) {
             continue;
         }
         for (const service of services) {
+            if (readOnlyIfPresent(service)) {
+                continue;
+            }
             if (parentDeclaredSet.has(service)) {
                 requiredServices.add(service);
             }
@@ -365,7 +375,9 @@ export function aggregateRequiredServices(state) {
     }
     if (usesAddonFn && addonFactoryNeeded) {
         for (const service of parentDeclared) {
-            requiredServices.add(service);
+            if (!readOnlyIfPresent(service)) {
+                requiredServices.add(service);
+            }
         }
     }
     // 8. When this project IS an addon, what it needs from its parent is whatever
@@ -402,6 +414,11 @@ export function validateSecretOverrides(logger, state) {
     // passes to getSecret — so validate against secretId, falling back to name for
     // older meta without a secretId field.
     const secretIds = new Set(state.secrets.definitions.map((d) => d.secretId ?? d.name));
+    // auth-secrets.gen.ts declares it, but that file is written after the first
+    // inspection of a fresh project, so its defineSecret is not seen yet — the
+    // same fallback validateSecretUsage takes.
+    if (state.auth?.definition)
+        secretIds.add('BETTER_AUTH_SECRET');
     for (const [namespace, addonDecl] of wireAddonDeclarations.entries()) {
         for (const [logicalName, resolvedName] of Object.entries(addonDecl.secretOverrides ?? {})) {
             if (!secretIds.has(resolvedName)) {
@@ -425,13 +442,20 @@ export function validateAddonUses(logger, state) {
     if (!wireAddonDeclarations || wireAddonDeclarations.size === 0)
         return;
     for (const [namespace, addonDecl] of wireAddonDeclarations.entries()) {
-        for (const [pkg, target] of Object.entries(addonDecl.uses ?? {})) {
+        for (const [name, target] of Object.entries(addonDecl.uses ?? {})) {
+            if (addonDecl.declaredUses && !addonDecl.declaredUses.includes(name)) {
+                logger.critical(ErrorCode.ADDON_USES_NOT_DECLARED, `Addon '${namespace}' maps '${name}' to '${target}', but ${addonDecl.package} does not declare '${name}' in the pikku.uses of its package.json. It declares: ${addonDecl.declaredUses.join(', ') || 'nothing'}. Remove '${name}' from uses, or have the addon declare it.`);
+                continue;
+            }
+            const expected = addonDecl.dependencies?.find((d) => d.alias === name)?.package ?? name;
             const wired = wireAddonDeclarations.get(target);
             if (!wired) {
-                logger.critical(ErrorCode.ADDON_USES_NOT_WIRED, `Addon '${namespace}' uses '${pkg}' as '${target}', but no addon is wired under the name '${target}'. Wired: ${Array.from(wireAddonDeclarations.keys()).join(', ')}`);
+                logger.critical(ErrorCode.ADDON_USES_NOT_WIRED, `Addon '${namespace}' uses '${name}' as '${target}', but no addon is wired under the name '${target}'. Wired: ${Array.from(wireAddonDeclarations.keys()).join(', ')}`);
             }
-            else if (wired.package !== pkg) {
-                logger.critical(ErrorCode.ADDON_USES_NOT_WIRED, `Addon '${namespace}' uses '${pkg}' as '${target}', but '${target}' is wired from '${wired.package}'.`);
+            else if (wired.package !== expected) {
+                logger.critical(ErrorCode.ADDON_USES_NOT_WIRED, expected === name
+                    ? `Addon '${namespace}' uses '${name}' as '${target}', but '${target}' is wired from '${wired.package}'.`
+                    : `Addon '${namespace}' calls ${expected} as '${name}', mapped to '${target}', but '${target}' is wired from '${wired.package}'.`);
             }
         }
     }

package/dist/utils/serialize-inspector-state.d.ts

@@ -118,6 +118,7 @@ export interface SerializableInspectorState {
         }]>;
         approvalDescriptions: InspectorState['functions']['approvalDescriptions'];
         dynamicImportIds?: string[];
+        disabled?: InspectorState['functions']['disabled'];
     };
     http: {
         metaInputTypes: Array<[
@@ -328,8 +329,8 @@ export interface SerializableInspectorState {
     diagnostics: InspectorDiagnostic[];
     addonFunctions: InspectorState['addonFunctions'];
     remoteAddonFunctions?: InspectorState['remoteAddonFunctions'];
-    screensManifest?: InspectorState['screensManifest'];
-    addonScreens?: InspectorState['addonScreens'];
+    studio?: InspectorState['studio'];
+    addonStudio?: InspectorState['addonStudio'];
     addonContributors?: InspectorState['addonContributors'];
     exportedContracts: InspectorState['exportedContracts'];
 }

package/dist/utils/serialize-inspector-state.js

@@ -41,6 +41,9 @@ export function serializeInspectorState(state) {
             files: Array.from(state.functions.files.entries()),
             approvalDescriptions: state.functions.approvalDescriptions,
             dynamicImportIds: Array.from(state.functions.dynamicImportIds ?? []),
+            ...(Object.keys(state.functions.disabled ?? {}).length > 0
+                ? { disabled: state.functions.disabled }
+                : {}),
         },
         http: {
             metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
@@ -191,8 +194,8 @@ export function serializeInspectorState(state) {
         diagnostics: state.diagnostics,
         addonFunctions: state.addonFunctions,
         remoteAddonFunctions: state.remoteAddonFunctions,
-        screensManifest: state.screensManifest,
-        addonScreens: state.addonScreens,
+        studio: state.studio,
+        addonStudio: state.addonStudio,
         addonContributors: state.addonContributors,
         exportedContracts: state.exportedContracts,
     };
@@ -240,6 +243,7 @@ export function deserializeInspectorState(data) {
             files: new Map(data.functions.files),
             approvalDescriptions: data.functions.approvalDescriptions || {},
             dynamicImportIds: new Set(data.functions.dynamicImportIds ?? []),
+            disabled: data.functions.disabled ?? {},
         },
         http: {
             metaInputTypes: new Map(data.http.metaInputTypes),
@@ -400,8 +404,8 @@ export function deserializeInspectorState(data) {
         ...(data.remoteAddonFunctions
             ? { remoteAddonFunctions: data.remoteAddonFunctions }
             : {}),
-        screensManifest: data.screensManifest,
-        addonScreens: data.addonScreens,
+        studio: data.studio,
+        addonStudio: data.addonStudio,
         addonContributors: data.addonContributors,
         exportedContracts: data.exportedContracts || {
             http: {},

package/dist/visit.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { addFileWithFactory } from './add/add-file-with-factory.js';
+import { addFileWithFactory, checkHiddenFactory, } from './add/add-file-with-factory.js';
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
 import { addHTTPRoute } from './add/add-http-route.js';
 import { addHTTPRoutes } from './add/add-http-routes.js';
@@ -15,7 +15,7 @@ import { addChannel } from './add/add-channel.js';
 import { addGateway } from './add/add-gateway.js';
 import { addRPCInvocations } from './add/add-rpc-invocations.js';
 import { addWireAddon } from './add/add-wire-addon.js';
-import { addDefineScreens } from './add/add-define-screens.js';
+import { addPikkuStudio } from './add/add-pikku-studio.js';
 import { addWireRemoteAddon } from './add/add-wire-remote-addon.js';
 import { addMiddleware } from './add/add-middleware.js';
 import { addPermission } from './add/add-permission.js';
@@ -36,6 +36,7 @@ import { addOutgoingWebhook } from './add/add-outgoing-webhook.js';
 import { addAgentScorer } from './add/add-agent-scorer.js';
 import { addApprovalDescription } from './add/add-approval-description.js';
 import { checkIndirectRegistrations } from './add/check-indirect-registrations.js';
+import { checkDisabledReferences } from './add/check-disabled-references.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -45,11 +46,12 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addFileWithFactory(node, checker, state.wireServicesFactories, 'CreateWireServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addFileWithFactory(node, checker, state.serverLifecycleFactories, 'ServerLifecycle');
+    checkHiddenFactory(logger, node, state);
     addAnalytics(logger, node, checker, state);
     addOutgoingWebhook(logger, node, checker, state);
     addRPCInvocations(node, state, logger);
     addWireAddon(node, state, logger);
-    addDefineScreens(node, state, logger);
+    addPikkuStudio(node, state, logger);
     addWireRemoteAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
@@ -100,5 +102,6 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addFeature(logger, node, checker, state, nextOptions);
     addAgent(logger, node, checker, state, nextOptions);
     addAgentScorer(logger, node, checker, state, nextOptions);
+    checkDisabledReferences(logger, node, checker, state, nextOptions);
     ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, nextOptions));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.110",
+  "version": "0.12.111",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -70,10 +70,10 @@
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.146"
+    "@pikku/core": "^0.12.147"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.146",
+    "@pikku/core": "^0.12.147",
     "@types/node": "^26.6.5"
   },
   "engines": {

package/dist/add/add-define-screens.d.ts

@@ -1,8 +0,0 @@
-import * as ts from 'typescript';
-import type { InspectorState, InspectorLogger } from '../types.js';
-/**
- * Detect `defineScreens({ title, icon, screens })` and record the manifest.
- * A screen with a field that is not a literal is reported and left out: a
- * navigation entry the host cannot read would otherwise vanish with no sign.
- */
-export declare function addDefineScreens(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-define-screens.js

@@ -1,140 +0,0 @@
-import * as ts from 'typescript';
-import { ErrorCode } from '../error-codes.js';
-const propName = (prop) => {
-    if (!ts.isPropertyAssignment(prop))
-        return undefined;
-    return ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
-        ? prop.name.text
-        : undefined;
-};
-const stringArray = (node) => {
-    if (!ts.isArrayLiteralExpression(node))
-        return undefined;
-    const values = [];
-    for (const element of node.elements) {
-        if (!ts.isStringLiteral(element))
-            return undefined;
-        values.push(element.text);
-    }
-    return values;
-};
-/**
- * The module specifier of `() => import('./screens/x')`. Anything else cannot
- * be handed to the host's bundler as a lazy import, so it is not read.
- */
-const lazyImportSpecifier = (node) => {
-    if (!ts.isArrowFunction(node))
-        return undefined;
-    const body = node.body;
-    if (!ts.isCallExpression(body) ||
-        body.expression.kind !== ts.SyntaxKind.ImportKeyword)
-        return undefined;
-    const [specifier] = body.arguments;
-    return specifier && ts.isStringLiteral(specifier) ? specifier.text : undefined;
-};
-/**
- * Detect `defineScreens({ title, icon, screens })` and record the manifest.
- * A screen with a field that is not a literal is reported and left out: a
- * navigation entry the host cannot read would otherwise vanish with no sign.
- */
-export function addDefineScreens(node, state, logger) {
-    if (!ts.isCallExpression(node))
-        return;
-    const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression) || expression.text !== 'defineScreens')
-        return;
-    const [firstArg] = args;
-    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
-        return;
-    const fail = (message) => logger.critical(ErrorCode.ADDON_SCREENS_NOT_STATIC, message);
-    let title;
-    let icon;
-    const screens = [];
-    for (const prop of firstArg.properties) {
-        const key = propName(prop);
-        if (!key || !ts.isPropertyAssignment(prop))
-            continue;
-        if (key === 'title' && ts.isStringLiteral(prop.initializer)) {
-            title = prop.initializer.text;
-        }
-        else if (key === 'icon' && ts.isStringLiteral(prop.initializer)) {
-            icon = prop.initializer.text;
-        }
-        else if (key === 'screens') {
-            if (!ts.isArrayLiteralExpression(prop.initializer)) {
-                fail(`defineScreens's screens must be an array literal, got: ${prop.initializer.getText()}`);
-                continue;
-            }
-            for (const element of prop.initializer.elements) {
-                if (!ts.isObjectLiteralExpression(element)) {
-                    fail(`A defineScreens screen must be an object literal, got: ${element.getText()}`);
-                    continue;
-                }
-                let path;
-                let screenTitle;
-                let nav;
-                let scopes;
-                let component;
-                let app;
-                for (const field of element.properties) {
-                    const fieldKey = propName(field);
-                    if (!fieldKey || !ts.isPropertyAssignment(field))
-                        continue;
-                    const value = field.initializer;
-                    if (fieldKey === 'path' && ts.isStringLiteral(value)) {
-                        path = value.text;
-                    }
-                    else if (fieldKey === 'title' && ts.isStringLiteral(value)) {
-                        screenTitle = value.text;
-                    }
-                    else if (fieldKey === 'nav' &&
-                        (value.kind === ts.SyntaxKind.TrueKeyword ||
-                            value.kind === ts.SyntaxKind.FalseKeyword)) {
-                        nav = value.kind === ts.SyntaxKind.TrueKeyword;
-                    }
-                    else if (fieldKey === 'scopes') {
-                        scopes = stringArray(value);
-                        if (!scopes) {
-                            fail(`A screen's scopes must be an array of string literals, got: ${value.getText()}`);
-                        }
-                    }
-                    else if (fieldKey === 'component') {
-                        component = lazyImportSpecifier(value);
-                        if (!component) {
-                            fail(`A screen's component must be () => import('<literal>'), got: ${value.getText()}`);
-                        }
-                    }
-                    else if (fieldKey === 'app' && ts.isStringLiteral(value)) {
-                        app = value.text;
-                    }
-                }
-                if (!path || !screenTitle || (!component && !app)) {
-                    fail(`A defineScreens screen needs a literal path and title, and either a lazy component or an app: ${element.getText()}`);
-                    continue;
-                }
-                if (component && app) {
-                    fail(`Screen '${path}' sets both component and app; a screen is one or the other`);
-                    continue;
-                }
-                screens.push({
-                    path,
-                    title: screenTitle,
-                    ...(nav !== undefined ? { nav } : {}),
-                    ...(scopes ? { scopes } : {}),
-                    ...(component ? { component } : { app: app }),
-                });
-            }
-        }
-    }
-    if (!title) {
-        fail(`defineScreens needs a literal title`);
-        return;
-    }
-    logger.debug(`• Found defineScreens: ${title} (${screens.length} screens)`);
-    state.screensManifest = {
-        title,
-        ...(icon ? { icon } : {}),
-        file: node.getSourceFile().fileName,
-        screens,
-    };
-}