marko 5.37.6 → 6.0.0-3.12

package/dist/translator/visitors/program/index.d.ts

@@ -0,0 +1,39 @@
+import { types as t } from "@marko/compiler";
+export declare let currentProgramPath: t.NodePath<t.Program>;
+export declare let cleanIdentifier: t.Identifier;
+export declare let htmlRendererIdentifier: t.Identifier;
+export declare let scopeIdentifier: t.Identifier;
+export declare function isScopeIdentifier(node: t.Node): node is t.Identifier;
+export type TemplateExport = {
+    id: string;
+    props: {
+        [prop: string]: TemplateExport;
+    } | undefined;
+};
+export type TemplateExports = TemplateExport["props"];
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        domExports?: {
+            template: string;
+            walks: string;
+            setup: string;
+            params: TemplateExport | undefined;
+            closures: string;
+        };
+    }
+}
+declare const _default: {
+    migrate: {
+        enter(this: unknown, program: t.NodePath<t.Program>): void;
+        exit(this: unknown): void;
+    };
+    analyze: {
+        enter(this: unknown, program: t.NodePath<t.Program>): void;
+        exit(this: unknown, program: t.NodePath<t.Program>): void;
+    };
+    translate: {
+        enter(this: unknown, program: t.NodePath<t.Program>): void;
+        exit(this: unknown, program: t.NodePath<t.Program>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/referenced-identifier.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    migrate(this: unknown, identifier: t.NodePath<t.Identifier>): void;
+    analyze(this: unknown, identifier: t.NodePath<t.Identifier>): void;
+    translate(this: unknown, identifier: t.NodePath<t.Identifier>): void;
+};
+export default _default;

package/dist/translator/visitors/scriptlet.d.ts

@@ -0,0 +1,8 @@
+import type { types as t } from "@marko/compiler";
+declare const _default: {
+    analyze(this: unknown, scriptlet: t.NodePath<t.MarkoScriptlet>): void;
+    translate: {
+        exit(this: unknown, scriptlet: t.NodePath<t.MarkoScriptlet>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/tag/attribute-tag.d.ts

@@ -0,0 +1,11 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    analyze: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    translate: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/tag/custom-tag.d.ts

@@ -0,0 +1,19 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "../../util/references";
+declare const kChildScopeBinding: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface MarkoTagExtra {
+        [kChildScopeBinding]?: Binding;
+    }
+}
+declare const _default: {
+    analyze: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    translate: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+};
+export default _default;
+export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;

package/dist/translator/visitors/tag/dynamic-tag.d.ts

@@ -0,0 +1,18 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "../../util/references";
+declare const kDOMBinding: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface MarkoTagExtra {
+        [kDOMBinding]?: Binding;
+    }
+}
+declare const _default: {
+    analyze: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    translate: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/tag/index.d.ts

@@ -0,0 +1,15 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    transform: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    analyze: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    translate: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/tag/native-tag.d.ts

@@ -0,0 +1,25 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "../../util/references";
+export declare const kNativeTagBinding: unique symbol;
+export declare const kSerializeMarker: unique symbol;
+declare const kGetterId: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface NodeExtra {
+        [kNativeTagBinding]?: Binding;
+        [kSerializeMarker]?: boolean;
+        [kGetterId]?: string;
+    }
+}
+declare const _default: {
+    transform: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    analyze: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+    translate: {
+        enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+        exit(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
+    };
+};
+export default _default;

package/dist/translator/visitors/text.d.ts

@@ -0,0 +1,7 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    translate: {
+        exit(this: unknown, text: t.NodePath<t.MarkoText>): void;
+    };
+};
+export default _default;

package/index.d.ts

@@ -13,72 +13,27 @@ declare global {
   namespace Marko {
     /** A mutable global object for the current render. */
     export interface Global {
-      /** A list of globals that should be serialized to the browser. */
-      serializedGlobals?: Record<string, boolean>;
+      [x: PropertyKey]: unknown;
+      /** An AbortSignal instance that, when aborted, stops further streamed content. */
+      signal?: AbortSignal;
       /** A CSP Nonce to add to each script output from Marko. */
       cspNonce?: string;
+      /** Used for rendering multiple Marko templates in a single hydrated page. */
+      renderId?: string;
       /** Used to uniquely identify a instance of a Marko runtime. */
       runtimeId?: string;
-      /** Used for rendering multiple Marko templates in a single hydrated page. */
-      componentIdPrefix?: string;
-      [attr: PropertyKey]: unknown;
+      /** A list of globals that should be serialized to the browser. */
+      serializedGlobals?:
+        | (string | number)[]
+        | Record<string | number, boolean>;
     }
 
     export type TemplateInput<Input> = Input & {
+      /**  Data available within all rendered templates as `$global`. */
       $global?: Global;
     };
 
-    export interface Out<Component extends Marko.Component = Marko.Component>
-      extends PromiseLike<RenderResult<Component>> {
-      /** The underlying ReadableStream Marko is writing into. */
-      stream: unknown;
-      /** A mutable global object for the current render. */
-      global: Global;
-      /** Disable all async rendering. Will error if something beings async. */
-      sync(): void;
-      /** Returns true if async rendering is disabled. */
-      isSync(): boolean;
-      /** Write unescaped text at the current stream position. */
-      write(val: string | void): this;
-      /** Write javascript content to be merged with the scripts Marko sends out on the next flush. */
-      script(val: string | void): this;
-      /** Returns the currently rendered html content. */
-      toString(): string;
-      /** Starts a new async/forked stream. */
-      beginAsync(options?: {
-        name?: string;
-        timeout?: number;
-        last?: boolean;
-      }): Out;
-      /** Marks the current stream as complete (async streams may still be executing). */
-      end(val?: string | void): this;
-      emit(eventName: PropertyKey, ...args: any[]): boolean;
-      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      prependListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      removeListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      /** Register a callback executed when the last async out has completed. */
-      onLast(listener: (next: () => void) => unknown): this;
-      /** Pipe Marko's stream to another stream. */
-      pipe(stream: unknown): this;
-      /** Emits an error on the stream. */
-      error(e: Error): this;
-      /** Schedules a Marko to flush buffered html to the underlying stream. */
-      flush(): this;
-      /** Creates a detached out stream (used for out of order flushing). */
-      createOut(): Out;
-      /** Write escaped text at the current stream position. */
-      text(val: string | void): void;
-    }
-
     /** Body content created from by a component, typically held in an object with a renderBody property. */
-
     export interface Body<
       in Params extends readonly any[] = [],
       out Return = void,
@@ -99,122 +54,8 @@ declare global {
     export type BodyParameters<B> =
       B extends Body<infer Params, any> ? Params : never;
 
-    export class Component<Input = unknown, State = unknown>
-      implements Emitter
-    {
-      /** A unique id for this instance. */
-      public readonly id: string;
-      /** The top level element rendered by this instance. */
-      public readonly el: Element | void;
-      /** The attributes passed to this instance. */
-      public readonly input: Input;
-      /** @deprecated */
-      public readonly els: Element[];
-      /** Mutable state that when changed causes a rerender. */
-      state: State;
-
-      /** Returns the amount of event handlers listening to a specific event. */
-      listenerCount(eventName: PropertyKey): number;
-      /**
-       * Used to wrap an existing event emitted and ensure that all events are
-       * cleaned up once this component is destroyed
-       * */
-      subscribeTo(
-        emitter: unknown,
-      ): Omit<Emitter, "listenerCount" | "prependListener" | "emit">;
-      /** Emits an event on the component instance. */
-      emit(eventName: PropertyKey, ...args: any[]): boolean;
-      /** Listen to an event on the component instance. */
-      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      /** Listen to an event on the component instance once. */
-      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      /** Listen to an event on the component instance before all other listeners. */
-      prependListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      /** Remove a listener from the component instance. */
-      removeListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      /** Remove all listeners from the component instance. */
-      removeAllListeners(eventName?: PropertyKey): this;
-      /** Removes the component instance from the DOM and cleans up all active event handlers including all children. */
-      destroy(): void;
-      /** Schedule an update (similar to if a state had been changed). */
-      forceUpdate(): void;
-      /** Generates a unique id derived from the current unique instance id (similar to :scoped in the template). */
-      elId(key?: string, index?: number): string;
-      /** @alias elId */
-      getElId(key?: string, index?: number): string;
-      /** Gets an element reference by its `key` attribute in the template. */
-      getEl<T extends Element | void = Element | void>(
-        key?: string,
-        index?: number,
-      ): T;
-      /** Gets all element references by their `key` attribute in the template. */
-      getEls<T extends Element[] = Element[]>(key: string): T;
-      /** Gets a component reference by its `key` attribute in the template. */
-      getComponent<T extends Component | void = Component | void>(
-        key: string,
-        index?: number,
-      ): T;
-      /** Gets all component references by their `key` attribute in the template. */
-      getComponents<T extends Component[] = Component[]>(key: string): T;
-      /** True if this instance has been removed from the dom. */
-      /** True if this instance is scheduled to rerender. */
-      isDestroyed(): boolean;
-      /** Replace the entire state object with a new one, removing old properties. */
-      replaceState(state: this["state"]): void;
-      /**
-       * Update a property on this.state (should prefer mutating this.state directly).
-       * When passed an object as the first argument, it will be merged into the state.
-       */
-      setState<Key extends PropertyKey>(
-        name: Key & keyof this["state"],
-        value: (this["state"] & Record<PropertyKey, unknown>)[Key],
-      ): void;
-      setState(value: Partial<this["state"]>): void;
-
-      /** Schedules an update related to a specific state property and optionally updates the value. */
-      setStateDirty<Key extends PropertyKey>(
-        name: Key & keyof this["state"],
-        value?: (this["state"] & Record<PropertyKey, unknown>)[Key],
-      ): void;
-      /** Synchronously flush any scheduled updates. */
-      update(): void;
-      /** Appends the dom for the current instance to a parent DOM element. */
-      appendTo(target: ParentNode): this;
-      /** Inserts the dom for the current instance after a sibling DOM element. */
-      insertAfter(target: ChildNode): this;
-      /** Inserts the dom for the current instance before a sibling DOM element. */
-      insertBefore(target: ChildNode): this;
-      /** Prepends the dom for the current instance to a parent DOM element. */
-      prependTo(target: ParentNode): this;
-      /** Replaces an existing DOM element with the dom for the current instance. */
-      replace(target: ChildNode): this;
-      /** Replaces the children of an existing DOM element with the dom for the current instance. */
-      replaceChildrenOf(target: ParentNode): this;
-      // /** Called when the component is firsted created. */
-      // onCreate?(input: this["input"], out: Marko.Out): void;
-      // /** Called every time the component receives input from it's parent. */
-      // onInput?(input: this["input"], out: Marko.Out): void | this["input"];
-      // /** Called after a component has successfully rendered, but before it's update has been applied to the dom. */
-      // onRender?(out: Marko.Out): void;
-      // /** Called after the first time the component renders and is attached to the dom. */
-      // onMount?(): void;
-      // /** Called when a components render has been applied to the DOM (excluding when it is initially mounted). */
-      // onUpdate?(): void;
-      // /** Called when a component is destroyed and removed from the dom. */
-      // onDestroy?(): void;
-    }
-
     /** The top level api for a Marko Template. */
     export abstract class Template<Input = unknown, Return = unknown> {
-      /** Creates a Marko compatible output stream. */
-      createOut(): Out;
-
       /**
        * The folowing types are processed up by the @marko/language-tools
        * and inlined into the compiled template.
@@ -226,99 +67,34 @@ declare global {
        */
 
       /** @marko-overload-start */
-      /** Asynchronously render the template. */
-      abstract render(
+      /** Render the template to a string. */
+      abstract render(input: Marko.TemplateInput<Input>): Promise<string> &
+        AsyncIterable<string> & {
+          toReadable(): ReadableStream;
+          pipe(stream: {
+            write(chunk: string): unknown;
+            end(): unknown;
+            flush?(): void;
+          }): void;
+          toString(): string;
+        };
+
+      /** Render and attach the template to a DOM node. */
+      abstract mount(
         input: Marko.TemplateInput<Input>,
-        stream?: {
-          write: (chunk: string) => void;
-          end: (chunk?: string) => void;
-        },
-      ): Marko.Out<Marko.Component>;
-
-      /** Asynchronously render the template in buffered mode. */
-      abstract render(
-        input: Marko.TemplateInput<Input>,
-        cb?: (
-          err: Error | null,
-          result: Marko.RenderResult<Marko.Component>,
-        ) => void,
-      ): Marko.Out<Marko.Component>;
-
-      /** Synchronously render the template. */
-      abstract renderSync(
-        input: Marko.TemplateInput<Input>,
-      ): Marko.RenderResult<Marko.Component>;
-
-      /** Synchronously render a template to a string. */
-      abstract renderToString(input: Marko.TemplateInput<Input>): string;
-
-      /** Render a template and return a stream.Readable in nodejs or a ReadableStream in a web worker environment. */
-      abstract stream(
-        input: Marko.TemplateInput<Input>,
-      ): ReadableStream<string> & NodeJS.ReadableStream;
+        reference: ParentNode & Node,
+        position?: "afterbegin" | "afterend" | "beforebegin" | "beforeend",
+      ): {
+        update(input: Marko.TemplateInput<Input>): void;
+        destroy(): void;
+      };
       /** @marko-overload-end */
     }
 
-    export interface RenderResult<
-      out Component extends Marko.Component = Marko.Component,
-    > {
-      /** Returns the component created as a result of rendering the template. */
-      getComponent(): Component;
-      getComponents(selector?: any): any;
-      /** Triggers the mount lifecycle of a component without necessarily attaching it to the DOM. */
-      afterInsert(host?: any): this;
-      /** Gets the DOM node rendered by a template. */
-      getNode(host?: any): Node;
-      /** Gets the HTML output of the rendered template. */
-      toString(): string;
-      /** Appends the dom of the rendered template to a parent DOM element. */
-      appendTo(target: ParentNode): this;
-      /** Inserts the dom of the rendered template after a sibling DOM element. */
-      insertAfter(target: ChildNode): this;
-      /** Inserts the dom of the rendered template before a sibling DOM element. */
-      insertBefore(target: ChildNode): this;
-      /** Prepends the dom of the rendered template to a parent DOM element. */
-      prependTo(target: ParentNode): this;
-      /** Replaces an existing DOM element with the dom of the rendered template. */
-      replace(target: ChildNode): this;
-      /** Replaces the children of an existing DOM element with the dom of the rendered template. */
-      replaceChildrenOf(target: ParentNode): this;
-      out: Out<Component>;
-      /** @deprecated */
-      document: any;
-      /** @deprecated */
-      getOutput(): string;
-      /** @deprecated */
-      html: string;
-      /** @deprecated */
-      context: Out<Component>;
-    }
-
-    export interface Emitter {
-      listenerCount(eventName: PropertyKey): number;
-      emit(eventName: PropertyKey, ...args: any[]): boolean;
-      on(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      once(eventName: PropertyKey, listener: (...args: any[]) => any): this;
-      prependListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      removeListener(
-        eventName: PropertyKey,
-        listener: (...args: any[]) => any,
-      ): this;
-      removeAllListeners(eventName?: PropertyKey): this;
-    }
-
     export type AttrTag<T> = T & {
       [Symbol.iterator](): Iterator<T>;
     };
 
-    /**
-     * @deprecated Prefer to use AttrTag
-     */
-    export type RepeatableAttrTag<T> = AttrTag<T>;
-
     export interface NativeTag<
       Input extends Record<string, any>,
       Return extends Element,
@@ -364,12 +140,5 @@ declare global {
               | Body<any, infer Return>
           ? Return
           : never;
-
-    /** @deprecated @see {@link Marko.Input} */
-    export type NativeTagInput<Name extends keyof NativeTags> =
-      NativeTags[Name]["input"];
-    /** @deprecated @see {@link Marko.Return} */
-    export type NativeTagReturn<Name extends keyof NativeTags> =
-      NativeTags[Name]["return"];
   }
 }

package/package.json

@@ -1,91 +1,64 @@
 {
   "name": "marko",
-  "version": "5.37.6",
-  "description": "UI Components + streaming, async, high performance, HTML templating for Node.js and the browser.",
+  "version": "6.0.0-3.12",
+  "description": "Optimized runtime for Marko templates.",
   "keywords": [
-    "front-end",
-    "templating",
-    "template",
-    "async",
-    "streaming",
-    "components",
-    "ui",
-    "vdom",
-    "dom",
-    "morphdom",
-    "virtual",
-    "virtual-dom"
+    "api",
+    "marko",
+    "runtime",
+    "tags"
   ],
-  "homepage": "https://markojs.com/",
+  "homepage": "https://github.com/marko-js/marko",
+  "bugs": "https://github.com/marko-js/marko/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/marko-js/marko.git",
-    "directory": "packages/runtime-class"
+    "directory": "packages/runtime-tags"
   },
   "license": "MIT",
-  "author": "Patrick Steele-Idem <pnidem@gmail.com>",
-  "maintainers": [
-    "Patrick Steele-Idem <pnidem@gmail.com>",
-    "Michael Rawlings <ml.rawlings@gmail.com>",
-    "Phillip Gates-Idem <phillip.idem@gmail.com>",
-    "Austin Kelleher <a@alk.im>",
-    "Dylan Piercey <pierceydylan@gmail.com>",
-    "Martin Aberer"
-  ],
-  "main": "index.js",
-  "browser": {
-    "./compiler.js": "./compiler-browser.marko",
-    "./components.js": "./components-browser.marko",
-    "./legacy-components.js": "./legacy-components-browser.marko",
-    "./index.js": "./index-browser.marko"
+  "exports": {
+    ".": {
+      "types": "./index.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./translator": "./dist/translator/index.js",
+    "./tag-types/*": "./tag-types/*",
+    "./debug/*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/debug/*.mjs",
+      "default": "./dist/debug/*.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.mjs",
+      "default": "./dist/*.js"
+    }
   },
   "types": "index.d.ts",
-  "bin": {
-    "markoc": "bin/markoc"
-  },
   "files": [
-    "bin",
     "dist",
-    "docs",
-    "src",
-    "helpers",
-    "browser-refresh.js",
-    "compiler-browser.marko",
-    "compiler.js",
-    "components-browser.marko",
-    "components.js",
-    "legacy-components-browser.marko",
-    "legacy-components.js",
-    "env.js",
+    "tag-types",
     "index.d.ts",
-    "index-browser.marko",
-    "index.js",
-    "node-require.js",
     "tags-html.d.ts",
-    "translator/package.json",
-    "translator/index.d.ts"
+    "!**/meta.*.json",
+    "!**/__tests__",
+    "!**/*.tsbuildinfo"
   ],
   "scripts": {
-    "build": "babel ./src --out-dir ./dist --extensions .js --copy-files --config-file ../../babel.config.js --env-name=production"
+    "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@babel/runtime": "^7.26.0",
     "@marko/compiler": "^5.39.5",
-    "app-module-path": "^2.2.0",
-    "argly": "^1.2.0",
-    "browser-refresh-client": "1.1.4",
-    "complain": "^1.6.1",
     "csstype": "^3.1.3",
-    "events-light": "^1.0.5",
-    "listener-tracker": "^2.0.0",
-    "magic-string": "^0.30.17",
-    "minimatch": "^9.0.5",
-    "raptor-util": "^3.2.0",
-    "resolve-from": "^5.0.0",
-    "self-closing-tags": "^1.0.1",
-    "warp10": "^2.1.0"
+    "magic-string": "^0.30.17"
   },
-  "logo": {
-    "url": "https://raw.githubusercontent.com/marko-js/branding/master/marko-logo-small.png"
+  "exports:override": {
+    ".": {
+      "types": "./index.d.ts"
+    },
+    "./translator": "./src/translator/index.ts",
+    "./tag-types/*": "./tag-types/*",
+    "./debug/*": "./src/*.ts",
+    "./*": "./src/*.ts"
   }
 }

package/tag-types/const.d.marko

@@ -0,0 +1,7 @@
+/** File for types only, not actual implementation **/
+
+export interface Input<T> {
+  value: T;
+}
+
+return=input.value

package/tag-types/debug.d.marko

@@ -0,0 +1,5 @@
+/** File for types only, not actual implementation **/
+
+export interface Input {
+  value?: unknown;
+}

package/tag-types/define.d.marko

@@ -0,0 +1,5 @@
+/** File for types only, not actual implementation **/
+
+export type Input<T> = T;
+
+return=input

package/tag-types/do.d.marko

@@ -0,0 +1,5 @@
+/** File for types only, not actual implementation **/
+
+export interface Input {
+  value?(): unknown;
+}

package/tag-types/effect.d.marko

@@ -0,0 +1,5 @@
+/** File for types only, not actual implementation **/
+
+export interface Input {
+  value?(): void;
+}