tungsten 0.6.3 → 0.7.1

package/dist/pipeline/pipeline.types.test.d.ts.map

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

package/dist/pipeline/pipeline.types.test.js

@@ -0,0 +1,344 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { route } from '../routing/builder.js';
+import { contextStore } from './contextStore.js';
+import { pipeline } from './pipeline.js';
+/*
+ * Type tests for the pipeline builder. tsc is the assertion - nothing here runs.
+ *
+ * Server -> Init -> (routing) -> Post. The components are typed with the last stage's context.
+ */
+class ApiClient {
+  constructor(reqRes) {
+    _defineProperty(this, "get", async path => Promise.resolve(path));
+    void reqRes;
+  }
+}
+const server = pipeline.server('express');
+const init = server.init(async reqRes => Promise.resolve({
+  api: new ApiClient(reqRes),
+  userId: 1
+}));
+const app = init.post((reqRes, {
+  api,
+  userId
+}) => ({
+  api,
+  cart: contextStore({
+    items: []
+  }),
+  counter: contextStore({
+    count: userId
+  })
+}));
+const {
+  SimpleComponent,
+  StatefulComponent,
+  SignalsComponent,
+  SimpleStoreComponent,
+  StatefulStoreComponent
+} = app;
+// ---- the components are typed with Post's context ---------------------------
+export class Page extends SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const api = this.tungsten.context.api;
+      const count = this.tungsten.context.counter.count.get();
+      void api;
+      void count;
+      void this.props.title;
+      return null;
+    });
+  }
+}
+export class Counter extends StatefulComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "state", {
+      n: 0
+    });
+    _defineProperty(this, "content", () => null);
+  }
+}
+export class Ticker extends SignalsComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "signals", {
+      n: 0
+    });
+    _defineProperty(this, "content", () => null);
+  }
+}
+// the app makes its store components, selecting the store from the context
+export class CountView extends SimpleStoreComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "store", this.createStore(({
+      counter
+    }) => counter));
+    _defineProperty(this, "content", () => {
+      const count = this.store.count.sync();
+      void count;
+      void this.props.label;
+      return null;
+    });
+  }
+}
+export class CartView extends StatefulStoreComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "state", {
+      open: false
+    });
+    _defineProperty(this, "store", this.createStore(({
+      cart
+    }) => cart));
+    _defineProperty(this, "content", () => null);
+  }
+}
+// the checks are real, not `any`
+export class NopeContext extends SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      // @ts-expect-error -- not on Post's context
+      void this.tungsten.context.nope;
+      return null;
+    });
+  }
+}
+export class WrongStore extends SimpleStoreComponent {
+  constructor(...args) {
+    super(...args);
+    // @ts-expect-error -- the cart is not a store of { count }
+    _defineProperty(this, "store", this.createStore(({
+      cart
+    }) => cart));
+    _defineProperty(this, "content", () => null);
+  }
+}
+// @ts-expect-error -- a store component has to make its store
+export class NoStore extends SimpleStoreComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => null);
+  }
+}
+// nothing crosses the network, so the context may hold anything
+server.init(reqRes => ({
+  reqRes,
+  when: new Date()
+}));
+// ---- stages may be skipped --------------------------------------------------
+// from Init, the context is Init's
+export class InitPage extends init.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const userId = this.tungsten.context.userId;
+      void userId;
+      return null;
+    });
+  }
+}
+// from the server, there is no context yet
+export class ServerPage extends server.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      // @ts-expect-error -- nothing made a context
+      void this.tungsten.context.api;
+      return null;
+    });
+  }
+}
+// Init may return nothing, leaving Post to make the context from nothing
+server.init(() => undefined).post((reqRes, initContext) => {
+  const nothing = initContext;
+  void nothing;
+  return {};
+});
+// Post may follow the server directly
+server.post(() => ({}));
+// ---- the request is the server's --------------------------------------------
+server.init(reqRes => {
+  const typed = reqRes;
+  void typed;
+  return undefined;
+});
+// hono's request is a placeholder until its handlers are written
+pipeline.server('hono').init(reqRes => {
+  // @ts-expect-error -- not express's
+  const typed = reqRes;
+  void typed;
+  return undefined;
+});
+// ---- all-routes data: after Init, before Post -------------------------------
+const withData = init.allRoutesData(async (reqRes, {
+  userId
+}) => {
+  // before any route renders: before SSR, with the request, or a client navigation, with null
+  // @ts-expect-error -- null on the client
+  const serverOnly = reqRes;
+  const typed = reqRes;
+  void serverOnly;
+  void typed;
+  return Promise.resolve({
+    theme: 'dark',
+    userId
+  });
+});
+export class ThemedPage extends withData.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const theme = this.tungsten.allRoutesData.theme;
+      void theme;
+      // @ts-expect-error -- not in the all-routes data
+      void this.tungsten.allRoutesData.nope;
+      return null;
+    });
+  }
+}
+// the route content functions and Post see it too
+withData.routes(() => ({
+  '/': {
+    content: (routeData, params, props, allRoutesData) => {
+      const theme = allRoutesData.theme;
+      void theme;
+      return null;
+    }
+  },
+  '404': {
+    content: null
+  }
+}));
+const initApi = stageOf().api;
+const initResultApi = stageOf().api;
+const postCounter = stageOf().counter;
+// @ts-expect-error -- Post's, not Init's
+void stageOf().userId;
+// the all-routes data stage: its data, with Init's context before it
+const withDataTheme = stageOf().theme;
+const withDataApi = stageOf().api;
+void initApi;
+void initResultApi;
+void postCounter;
+void withDataTheme;
+void withDataApi;
+// an earlier stage's, by name
+const namedInitApi = stageOf().api;
+const namedData = stageOf().theme;
+// @ts-expect-error -- app's chain had no all-routes data
+void stageOf();
+void namedInitApi;
+void namedData;
+const withPost = withData.post((reqRes, initContext, allRoutesData) => {
+  const theme = allRoutesData.theme;
+  return {
+    theme
+  };
+});
+export class AfterPostPage extends withPost.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const theme = this.tungsten.allRoutesData.theme;
+      void theme;
+      return null;
+    });
+  }
+}
+// @ts-expect-error -- it is serialized into the page
+init.allRoutesData(reqRes => ({
+  leaked: reqRes
+}));
+// @ts-expect-error -- taken once
+withData.allRoutesData(() => ({}));
+// @ts-expect-error -- and not after Post
+app.allRoutesData(() => ({}));
+// none given: nothing to read
+export class NoDataPage extends app.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      // @ts-expect-error -- no all-routes data
+      void this.tungsten.allRoutesData.theme;
+      const absent = this.tungsten.allRoutesData;
+      void absent;
+      return null;
+    });
+  }
+}
+// ---- routes: off any stage, with Init's context -----------------------------
+const _routes = app.routes((reqRes, {
+  api,
+  userId
+}) => {
+  const typedApi = api;
+  const typedUserId = userId;
+  void typedApi;
+  void typedUserId;
+  return [route({
+    path: '/foo',
+    content: null
+  }), route({
+    path: '404',
+    content: null
+  })];
+});
+// the app keeps the function as given, for the route and path types
+const fooPath = '/foo';
+// @ts-expect-error -- not one of its routes
+const nopePath = '/nope';
+void fooPath;
+void nopePath;
+// and a typed link's
+const linkPath = '/foo';
+// @ts-expect-error -- not one of its routes
+const nopeLinkPath = '/nope';
+void linkPath;
+void nopeLinkPath;
+app.routes((reqRes, initContext) => {
+  // @ts-expect-error -- routing runs before Post, so Post's cart is not there yet
+  void initContext.cart;
+  return [];
+});
+server.routes((reqRes, initContext) => {
+  const nothing = initContext;
+  void nothing;
+  return [];
+});
+// the options come first when given, and the routes still see Init's context
+app.routes({
+  cacheControl: 'no-store'
+}, (reqRes, {
+  api
+}) => {
+  const typedApi = api;
+  void typedApi;
+  return [];
+});
+// @ts-expect-error -- not a cache policy
+app.routes({
+  cacheControl: 'sometimes'
+}, () => []);
+// @ts-expect-error -- a path given twice is caught after the options too
+app.routes({}, () => [{
+  path: '/a',
+  content: null
+}, {
+  path: '/a',
+  content: null
+}]);
+// ---- a stage cannot be taken twice, or out of order -------------------------
+// @ts-expect-error -- .init is gone once taken
+init.init(() => undefined);
+// @ts-expect-error -- .init cannot follow .post
+app.init(() => undefined);
+// @ts-expect-error -- .server is taken once
+server.server('express');
+// @ts-expect-error -- and only names a server tungsten knows
+pipeline.server('koa');

package/dist/pipeline/pipelineDefinition.d.ts

@@ -0,0 +1,78 @@
+import type { RouteCacheControl } from '../cacheControl.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { RouteKey } from '../routing/RouteTypes.js';
+export type ServerRequests = {
+    express: ReqRes;
+    hono: unknown;
+};
+export type ServerKind = keyof ServerRequests;
+export type StageContext = object;
+export type MaybePromise<T> = T | Promise<T>;
+export type AllRoutesDataConstraint = object | undefined;
+export type RegisteredStage = (reqRes: unknown, previous: StageContext | undefined, allRoutesData?: AllRoutesDataConstraint) => MaybePromise<StageContext | undefined>;
+export type SplitResult = {
+    context?: object;
+    networked?: object;
+};
+export type RegisteredServerInit = (reqRes: unknown) => MaybePromise<SplitResult | undefined>;
+export type RegisteredServerPost = (reqRes: unknown, init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type RegisteredClientInit = (networked: object) => MaybePromise<SplitResult | undefined>;
+export type RegisteredClientAllRoutesData = (init: SplitResult | undefined) => MaybePromise<object>;
+export type RegisteredClientPost = (init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type ClientRoute = {
+    key: RouteKey | null;
+    params: Record<string, string>;
+    data: unknown;
+    location: string;
+};
+export declare const clientRoute: (matched: MatchedRouteInfo, location: string) => ClientRoute;
+export type RegisteredClientAfterRouting = (context: object, route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type ClientRun = (app: PipelineApp, fromPage: unknown) => Promise<ClientStarted>;
+export type ClientStarted = {
+    init: StageContext | undefined;
+    routingContext: object;
+    routingNetworkedData: object;
+    allRoutesData: (() => MaybePromise<object>) | undefined;
+    networked: object;
+    post: (allRoutesData: AllRoutesDataConstraint) => Promise<ClientPosted>;
+};
+export type ClientPosted = {
+    context: object;
+    afterRouting: ((route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => Promise<object>) | undefined;
+};
+export type RegisteredRoutes = (reqRes: unknown, init: StageContext | undefined) => unknown;
+export type RegisteredAllRoutesData = (reqRes: unknown, init: StageContext | undefined) => MaybePromise<object>;
+export type RoutesOptions = {
+    cacheControl?: RouteCacheControl;
+};
+export type PipelineDefinition = {
+    server: ServerKind;
+    split?: true;
+    client: ClientRun;
+    init?: RegisteredStage;
+    allRoutesData?: RegisteredAllRoutesData;
+    post?: RegisteredStage;
+    serverInit?: RegisteredServerInit;
+    serverPost?: RegisteredServerPost;
+    clientInit?: RegisteredClientInit;
+    clientAllRoutesData?: RegisteredClientAllRoutesData;
+    clientPost?: RegisteredClientPost;
+    clientAfterRouting?: RegisteredClientAfterRouting;
+};
+export declare const $pipelineApp: unique symbol;
+declare const $appTypes: unique symbol;
+export type PipelineApp<R = unknown, Ctx = unknown, N = unknown, G = unknown> = PipelineDefinition & {
+    readonly [$pipelineApp]: true;
+    readonly routes: R;
+    readonly routesOptions: RoutesOptions;
+    readonly [$appTypes]?: {
+        context: Ctx;
+        networked: N;
+        allRoutesData: G;
+    };
+};
+export declare const isPipelineApp: (value: unknown) => value is PipelineApp;
+export declare const appRoutesFunction: (app: PipelineApp) => RegisteredRoutes;
+export {};
+//# sourceMappingURL=pipelineDefinition.d.ts.map

package/dist/pipeline/pipelineDefinition.d.ts.map

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

package/dist/pipeline/pipelineDefinition.js

@@ -0,0 +1,11 @@
+export const clientRoute = (matched, location) => ({
+  key: matched.key,
+  params: matched.params,
+  data: matched.data,
+  location
+});
+export const $pipelineApp = Symbol('tungsten pipeline app');
+export const isPipelineApp = value => typeof value === 'object' && value !== null && $pipelineApp in value;
+// the routes function as the runners call it
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- typed by the stage
+export const appRoutesFunction = app => app.routes;