@tamagui/compiler-core 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/types/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../src/output.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAG/D,MAAM,WAAW,UAAU;IACzB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,UAAU,CAAA;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,CAAC,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,OAAO,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IACnC,cAAc,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;IAC1C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAC9B;AAED,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,gBAAgB,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;CAC7B;AASD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAkBtF;AA2ED,uFAAuF;AACvF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,gBAAgB,EACpB,IAAI,EAAE,2BAA2B,GAChC,oBAAoB,CAwBtB"}

package/types/planCache.d.ts

@@ -0,0 +1,113 @@
+import type { HostModuleInput, ResolvedModuleId } from './contracts';
+import { type LoweredModulePlan } from './lower';
+export declare const PLAN_CACHE_SCHEMA_VERSION = 1;
+/**
+ * Entries are content addressed, so every edit of a shared module writes new
+ * files and nothing ever replaces the old ones. Twenty edits of one module a
+ * hundred consumers import leaves two thousand dead entries that would live
+ * forever. A pruned entry is just a miss, and a miss recompiles, so dropping
+ * entries can never be wrong - only slower.
+ *
+ * The cap has to sit well above the module count of a real project, or an
+ * unchanged rebuild of a project larger than the cap would miss on every module
+ * the last build evicted. Twenty thousand entries is a few hundred MB at the
+ * high end and comfortably holds a large app plus several generations of edits.
+ *
+ * It is a soft cap: pruning runs between batches of writes, so a store can sit
+ * up to one batch above it. Bounding growth is the point, not an exact size.
+ */
+export declare const PLAN_CACHE_MAX_ENTRIES = 20000;
+/**
+ * The one on-disk cache location for a project. Metro's plan manifest already
+ * lives under it, and the build-time benchmark's "cold" state is defined as
+ * deleting it, so everything the compiler persists belongs here and nowhere
+ * else.
+ */
+export declare function tamaguiCacheRoot(projectRoot: string): string;
+export declare function defaultPlanCacheRoot(projectRoot: string, target: string): string;
+/**
+ * Everything a plan depends on that is not a module: the compiler build, the
+ * evaluated Tamagui config and component registry, the platform, and the
+ * structural pass. `stamp` comes from `loadCompilerProject`'s `cacheStamp`.
+ */
+export interface PlanCacheIdentity {
+    stamp: string;
+    target: string;
+    structuralPassHash: string;
+}
+export interface PlanCacheEntry {
+    schemaVersion: typeof PLAN_CACHE_SCHEMA_VERSION;
+    moduleId: ResolvedModuleId;
+    /** Digest of this module plus its whole non-external import closure. */
+    closureDigest: string;
+    plan: LoweredModulePlan;
+}
+export interface ModuleClosureNode {
+    contentHash: string;
+    /** Non-external dependencies only: the edges symbol resolution can cross. */
+    dependencies: readonly ResolvedModuleId[];
+}
+export type ModuleClosureLookup = (id: ResolvedModuleId) => ModuleClosureNode | null;
+/**
+ * Reads a closure node straight off host module records, for callers that have
+ * not built a ProjectGraph (Metro's prepass skips it entirely on a full hit).
+ */
+export declare function moduleClosureNode(input: HostModuleInput): ModuleClosureNode;
+/**
+ * Identity of a module's whole compile input: itself plus every module reachable
+ * from it over non-external imports, each by content hash.
+ *
+ * This is deliberately the import closure rather than the dependency set a
+ * successful compile recorded. The recorded set is only known after compiling,
+ * and it omits the module that made a value bail, so a dependency edit that
+ * turns a bailout into a static value would not invalidate its consumer, which
+ * is exactly how a stale style ships. The import closure is the same edge set
+ * `ProjectGraph.affectedBy` propagates over in memory, so it can never
+ * invalidate less than a live session would.
+ *
+ * Null when any module in the closure is unknown: an unknown input is a miss,
+ * never a guess.
+ */
+export declare function moduleClosureDigest(id: ResolvedModuleId, lookup: ModuleClosureLookup, memo?: Map<ResolvedModuleId, string | null>): string | null;
+export declare function planCacheKey(identity: PlanCacheIdentity, id: ResolvedModuleId, closureDigest: string): string;
+/**
+ * Content-addressed JSON entries on disk, one file per key. There is no
+ * manifest on purpose: a manifest is what makes a cache all-or-nothing, and the
+ * point of these caches is that editing one module leaves every other module's
+ * entry valid.
+ */
+export declare class JsonFileCache {
+    #private;
+    readonly root: string;
+    readonly schemaVersion: number;
+    readonly maxEntries: number;
+    constructor(root: string, schemaVersion: number, maxEntries?: number);
+    get stats(): {
+        hits: number;
+        misses: number;
+        writes: number;
+    };
+    resetStats(): void;
+    /**
+     * Null on anything short of an entry `validate` fully accepts. A miss
+     * recompiles; nothing here repairs or partially trusts an entry, and a later
+     * successful compile overwrites the bad file.
+     */
+    read<T>(key: string, validate: (value: unknown) => T | null): Promise<T | null>;
+    write(key: string, value: unknown): Promise<void>;
+}
+/** Per-module lowering plans, keyed by `planCacheKey`. */
+export declare class ModulePlanCache {
+    #private;
+    readonly root: string;
+    constructor(root: string);
+    get stats(): {
+        hits: number;
+        misses: number;
+        writes: number;
+    };
+    resetStats(): void;
+    read(key: string, id: ResolvedModuleId, closureDigest: string): Promise<PlanCacheEntry | null>;
+    write(key: string, entry: PlanCacheEntry): Promise<void>;
+}
+//# sourceMappingURL=planCache.d.ts.map

package/types/planCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planCache.d.ts","sourceRoot":"","sources":["../src/planCache.ts"],"names":[],"mappings":"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"}

package/types/session.d.ts

@@ -0,0 +1,44 @@
+import type { HostModuleInput, ResolvedModuleId } from './contracts';
+import type { GraphInvalidation } from './graph';
+import type { CompilerLoweringHost, CompilerTarget, LoweredModulePlan, StructuralModulePass } from './lower';
+import type { AppliedLoweredModule } from './output';
+import type { ModulePlanCache } from './planCache';
+export interface CompilerAdapter {
+    target: CompilerTarget;
+    projectGeneration: string;
+    host: CompilerLoweringHost;
+    load(id: ResolvedModuleId): Promise<HostModuleInput | null>;
+    /**
+     * Persistent per-module plan reuse across processes. Absent means the host
+     * could not produce a content stamp for this project, so nothing is cached
+     * rather than cached under a stamp that does not describe the config.
+     */
+    planCache?: {
+        store: ModulePlanCache;
+        stamp: string;
+    };
+}
+export interface CompileModuleInput {
+    module: HostModuleInput;
+    adapter: CompilerAdapter;
+    structuralPass?: StructuralModulePass;
+}
+export interface CompilerSessionResult {
+    plan: LoweredModulePlan;
+    output: AppliedLoweredModule;
+    invalidatedIds: ResolvedModuleId[];
+}
+/**
+ * Bundler-neutral compiler state. The adapter owns module resolution and loading;
+ * the session only accepts canonical host-resolved module records.
+ */
+export declare class CompilerSession {
+    #private;
+    compile(input: CompileModuleInput): Promise<CompilerSessionResult>;
+    update(module: HostModuleInput): Promise<ResolvedModuleId[]>;
+    has(id: ResolvedModuleId): boolean;
+    dependentsOf(id: ResolvedModuleId): ResolvedModuleId[];
+    remove(id: ResolvedModuleId): Promise<GraphInvalidation>;
+    parseCount(id: ResolvedModuleId): number;
+}
+//# sourceMappingURL=session.d.ts.map

package/types/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,OAAO,KAAK,EACV,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,cAAc,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,IAAI,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAA;IAC3D;;;;OAIG;IACH,SAAS,CAAC,EAAE;QAAE,KAAK,EAAE,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CACtD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,eAAe,CAAA;IACxB,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,oBAAoB,CAAA;IAC5B,cAAc,EAAE,gBAAgB,EAAE,CAAA;CACnC;AAMD;;;GAGG;AACH,qBAAa,eAAe;;IAI1B,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAIjE;IAED,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAE3D;IAED,GAAG,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAEjC;IAED,YAAY,CAAC,EAAE,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAErD;IAED,MAAM,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAEvD;IAED,UAAU,CAAC,EAAE,EAAE,gBAAgB,GAAG,MAAM,CAEvC;CA6FF"}

package/types/yuku.d.ts

@@ -0,0 +1,4 @@
+import type { AstNode, CandidateFactory } from './contracts';
+export declare const yukuFactory: CandidateFactory;
+export declare function parseModuleAst(source: string, id?: string): AstNode;
+//# sourceMappingURL=yuku.d.ts.map

package/types/yuku.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yuku.d.ts","sourceRoot":"","sources":["../src/yuku.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,OAAO,EACP,gBAAgB,EAKjB,MAAM,aAAa,CAAA;AAgIpB,eAAO,MAAM,WAAW,EAAE,gBA+BzB,CAAA;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,EAAE,SAAiC,GAClC,OAAO,CAcT"}

package/types/zero.d.ts

@@ -0,0 +1,98 @@
+import type { ResolvedModuleId, SourceSpan } from './contracts';
+import type { BailoutReason, ZeroRule } from './diagnostics';
+import type { LoweredModulePlan } from './lower';
+import type { SourceEdit } from './output';
+/**
+ * Zero-runtime reference erasure and the rule-mapped diagnostics that gate it.
+ *
+ * A passing lowering plan already proved every Tamagui use in this module became
+ * host markup. That fact is stronger than anything a bundler can derive, so the
+ * compiler removes the now-dead references before the bundler records this
+ * module's dependencies. Metro fixes its dependency graph at resolution time and
+ * does no export-level shaking, so nothing later in the pipeline can do this.
+ */
+export type { ZeroRule };
+export type ZeroViolationCode = 'zero/static-island-import' | 'zero/side-effect-import' | 'zero/live-tamagui-reference' | 'zero/design-state-read' | 'zero/runtime-provider' | BailoutReason['code'];
+export interface ZeroViolation {
+    rule: ZeroRule;
+    code: ZeroViolationCode;
+    span: SourceSpan;
+    message: string;
+    component?: string;
+}
+/** The last line of every zero-runtime failure, in both gates. */
+export declare const ZERO_FAILURE_FOOTER = "Fix every site or move the owning module to a declared full-runtime island. Zero-runtime never retains one component as a fallback.";
+/**
+ * The JavaScript design-state surface. A reference to any of these in a zero
+ * graph is rule 7: the value only exists once a runtime has parsed the config.
+ */
+export declare const ZERO_DESIGN_STATE_APIS: Set<string>;
+/** Root providers. Their use is illegal in a zero graph, never erasable. */
+export declare const ZERO_PROVIDER_EXPORTS: Set<string>;
+/**
+ * The four public animated-number hooks. They are the one opt-in runtime a zero
+ * graph may keep, and only through the leaf module: the public barrel would drag
+ * the config-bound driver resolution in with them.
+ */
+export declare const ZERO_ANIMATED_NUMBER_HOOKS: Set<string>;
+export declare const ZERO_ANIMATED_NUMBER_MODULE = "@tamagui/animations-css/animated-number";
+export interface ZeroRuleParams {
+    component?: string;
+    expression?: string;
+    prop?: string;
+    detail?: string;
+    api?: string;
+    /** Rule 8 only: what to do about this import, which differs per code. */
+    remediation?: string;
+}
+/** The rule map's developer messages, verbatim. */
+export declare function zeroRuleMessage(rule: ZeroRule, params: ZeroRuleParams): string;
+/**
+ * Rule 8's two codes.
+ *
+ * They are module-level imports rather than element sites, and neither one is
+ * fixed by moving the module to an island: a stray side-effect import wants
+ * deleting, and an island import wants the generated loader. Reporting them as
+ * rule 6 sent developers to do island work that would not have helped.
+ */
+export declare function zeroSideEffectImportMessage(specifier: string): string;
+export declare function zeroStaticIslandImportMessage(specifier: string, islandId: string): string;
+export declare const ZERO_PROVIDER_MESSAGE = "[tamagui zero-runtime] Rule 4: TamaguiProvider is not used by a zero-runtime root. The bundler loads generated CSS and the compiler lowers static Theme nodes. Remove this provider or make this entry full-runtime.";
+export declare function zeroThemeBoundaryMessage(component: string, prop: string): string;
+export declare function zeroConfigDriverMessage(name: string, outputStyle: unknown): string;
+export declare function zeroIslandThemeMessage(entry: string): string;
+/**
+ * The lowering plan's own diagnostics, read as zero-runtime violations.
+ *
+ * Only the diagnostics that stopped a candidate from lowering count: one
+ * recorded next to a successful lowering describes a dropped prop and leaves no
+ * runtime behind.
+ */
+export declare function zeroViolationsFromPlan(plan: LoweredModulePlan): ZeroViolation[];
+export interface ZeroErasureInput {
+    id: ResolvedModuleId;
+    source: string;
+    /** Edits already committed by lowering. A reference inside one is consumed. */
+    loweredEdits: readonly SourceEdit[];
+    /** True when this import specifier names the zero-forbidden Tamagui surface. */
+    isTamaguiSpecifier(specifier: string): boolean;
+    /** Returns the island id when this specifier names a declared island module. */
+    islandIdFor(specifier: string): string | null;
+}
+export interface ZeroErasureResult {
+    edits: SourceEdit[];
+    removedModules: string[];
+    removedBindings: string[];
+    erasedStyledDefinitions: string[];
+    /**
+     * Erased declarators this module also exported. The build-wide gate proves
+     * every importer of them inside the zero entry graph was itself transformed.
+     */
+    erasedExports: string[];
+    /** Hooks rewritten to the animated-number leaf, by their imported name. */
+    rewrittenAnimatedNumberHooks: string[];
+    liveBindings: string[];
+    violations: ZeroViolation[];
+}
+export declare function planZeroErasure(input: ZeroErasureInput): ZeroErasureResult;
+//# sourceMappingURL=zero.d.ts.map

package/types/zero.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zero.d.ts","sourceRoot":"","sources":["../src/zero.ts"],"names":[],"mappings":"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"}