@praxisjs/core 1.8.3 → 2.1.0

package/src/component/internals.ts

@@ -0,0 +1,119 @@
+export const componentPropsType: unique symbol = Symbol("praxis.componentPropsType");
+
+interface ComponentInternals<T extends object> {
+  rawProps: T;
+  mounted: boolean;
+  anchor?: Comment;
+  defaults: Record<string, unknown>;
+  stateDirty: boolean;
+}
+
+const componentInternals = new WeakMap<object, ComponentInternals<object>>();
+
+function getInternals(instance: object): ComponentInternals<object> {
+  const internals = componentInternals.get(instance);
+  if (!internals) {
+    throw new TypeError("Expected a PraxisJS component instance.");
+  }
+  return internals;
+}
+
+export function initComponentInternals(
+  instance: object,
+  props: object,
+): void {
+  componentInternals.set(instance, {
+    rawProps: { ...props },
+    mounted: false,
+    defaults: {},
+    stateDirty: false,
+  });
+}
+
+export function getComponentProps(instance: object): object {
+  return getInternals(instance).rawProps;
+}
+
+export function setComponentProps(
+  instance: object,
+  props: Record<string, unknown>,
+): void {
+  const rawProps = getInternals(instance).rawProps as Record<string, unknown>;
+  Object.keys(rawProps).forEach((key) => {
+    Reflect.deleteProperty(rawProps, key);
+  });
+  Object.assign(rawProps, props);
+}
+
+export function getComponentRawProp(
+  instance: object,
+  name: string,
+): unknown {
+  return (getInternals(instance).rawProps as Record<string, unknown>)[name];
+}
+
+export function getComponentDefault(
+  instance: object,
+  name: string,
+): unknown {
+  return getInternals(instance).defaults[name];
+}
+
+export function setComponentDefault(
+  instance: object,
+  name: string,
+  value: unknown,
+): void {
+  getInternals(instance).defaults[name] = value;
+}
+
+export function getComponentDefaults(
+  instance: object,
+): Record<string, unknown> {
+  return getInternals(instance).defaults;
+}
+
+export function getComponentAnchor(instance: object): Comment | undefined {
+  return getInternals(instance).anchor;
+}
+
+export function setComponentAnchor(
+  instance: object,
+  anchor: Comment | undefined,
+): void {
+  getInternals(instance).anchor = anchor;
+}
+
+export function isComponentMounted(instance: object): boolean {
+  return getInternals(instance).mounted;
+}
+
+export function setComponentMounted(
+  instance: object,
+  mounted: boolean,
+): void {
+  getInternals(instance).mounted = mounted;
+}
+
+export function markStateDirty(instance: object): void {
+  const internals = componentInternals.get(instance);
+  if (internals) {
+    internals.stateDirty = true;
+  }
+}
+
+export function isStateDirty(instance: object): boolean {
+  const internals = componentInternals.get(instance);
+  if (internals) return internals.stateDirty;
+  return false;
+}
+
+export function setStateDirty(
+  instance: object,
+  stateDirty: boolean,
+): void {
+  const internals = componentInternals.get(instance);
+  if (internals) {
+    internals.stateDirty = stateDirty;
+  }
+}

package/src/component/stateful.ts

@@ -2,24 +2,4 @@ import { RootComponent } from "./base";
 
 export abstract class StatefulComponent extends RootComponent<
   Record<string, unknown>
-> {
-  /**
-   * Default field values declared in the class, used to reset props on update.
-   * @internal
-   */
-  readonly _defaults: Record<string, unknown> = {};
-
-  /**
-   * Set to `true` by `@State` on any write; cleared by the renderer after each re-render.
-   * @internal
-   */
-  _stateDirty = false;
-
-  /**
-   * Raw props. Use `@Prop()` fields instead of reading this directly in user code.
-   * @internal
-   */
-  override get props(): Record<string, unknown> {
-    return this._rawProps;
-  }
-}
+> {}

package/src/component/stateless.ts

@@ -1,14 +1,15 @@
 import type { Children } from "@praxisjs/shared";
 
 import { RootComponent } from "./base";
+import { getComponentProps } from "./internals";
 
 type StatelessComponentType<T> = T & { children?: Children };
 
 export abstract class StatelessComponent<
   T extends object = Record<never, never>,
 > extends RootComponent<StatelessComponentType<T>> {
-  /** Public props API for presentational components — see `RootComponent.props`. */
-  override get props(): StatelessComponentType<T> {
-    return this._rawProps;
+  /** Public props API for presentational components. */
+  get props(): StatelessComponentType<T> {
+    return getComponentProps(this) as StatelessComponentType<T>;
   }
 }

package/src/internal.ts

@@ -19,11 +19,29 @@ export {
   type SyncedSignal,
 } from "./signal";
 export { RootComponent } from "./component";
+export {
+  componentPropsType,
+  getComponentAnchor,
+  getComponentDefault,
+  getComponentDefaults,
+  getComponentProps,
+  getComponentRawProp,
+  isComponentMounted,
+  isStateDirty,
+  markStateDirty,
+  setComponentAnchor,
+  setComponentDefault,
+  setComponentMounted,
+  setComponentProps,
+  setStateDirty,
+} from "./component/internals";
 export {
   resource,
   createResource,
+  flushPendingResources,
   type ResourceStatus,
   type Resource,
   type ResourceOptions,
 } from "./async/resource";
-export { invalidateResource, _clearCache } from "./async/resource-cache";
+export { invalidateResource, trackPendingResource, _clearCache } from "./async/resource-cache";
+export { setServerRenderPass, isServerRenderPass } from "./async/server-mode";