@revealui/core 0.0.1-pre.0 → 0.0.1-pre.2

package/dist/core/processing/parsers/parseEsModule.ts

@@ -1,43 +0,0 @@
-export { getModuleExportNames, getImportStatements };
-export type { ImportStatement };
-
-import { init, parse } from "es-module-lexer";
-import { assert } from "../../../plugins/utils.js";
-
-type ParseResult = ReturnType<typeof parse>;
-type ImportStatement = ParseResult[0][0];
-
-async function getModuleExportNames(
-  src: string,
-): Promise<{ exportNames: string[]; wildcardReExports: string[] }> {
-  const parseResult = await parseEsModule(src);
-  const [imports, exports] = parseResult;
-
-  const exportNames = exports.map((e) => e.n);
-
-  // This seems to be the only way to detect re-exports
-  //  - https://github.com/brillout/es-module-lexer_tests
-  //  - https://github.com/vitejs/vite/blob/8469bf0a5e38cbf08ec28e598ab155d339edc442/packages/vite/src/node/optimizer/index.ts#L978-L981
-  const wildcardReExports: string[] = [];
-  imports.forEach(({ n, ss, se }) => {
-    const exp = src.slice(ss, se);
-    if (/export\s+\*\s+from/.test(exp)) {
-      // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
-      assert(n);
-      wildcardReExports.push(n);
-    }
-  });
-
-  return { wildcardReExports, exportNames };
-}
-
-async function getImportStatements(src: string): Promise<ImportStatement[]> {
-  const parseResult = await parseEsModule(src);
-  const imports = parseResult[0].slice();
-  return imports;
-}
-
-async function parseEsModule(src: string) {
-  await init;
-  return parse(src);
-}

package/dist/core/processing/parsers/parseTransform.ts

@@ -1,36 +0,0 @@
-import { types } from "../serializers/stringifyTypes"
-
-export { parse }
-// Used by reveal: https://github.com/revealjs/reveal/blob/b4ba6b70e6bdc2e1f460c0d2e4c3faae5d0a733c/reveal/shared/page-configs/serialize/parseConfigValuesSerialized.ts#L13
-export { parseTransform }
-
-function parse(str: string): unknown {
-  // We don't use the reviver option in `JSON.parse(str, reviver)` because it doesn't support `undefined` values
-  const value = JSON.parse(str)
-  return parseTransform(value)
-}
-
-function parseTransform(value: unknown): unknown {
-  if (typeof value === "string") {
-    return reviver(value)
-  }
-  if (
-    // Also matches arrays
-    typeof value === "object" &&
-    value !== null
-  ) {
-    Object.entries(value).forEach(([key, val]: [string, unknown]) => {
-      ;(value as Record<string, unknown>)[key] = parseTransform(val)
-    })
-  }
-  return value
-}
-
-function reviver(value: string) {
-  for (const { match, deserialize } of types) {
-    if (match(value)) {
-      return deserialize(value, parse)
-    }
-  }
-  return value
-}

package/dist/core/processing/serializers/notSerializable.ts

@@ -1,2 +0,0 @@
-// TODO: move to ../node/runtime/html/notSerializable.ts once code is distributed as ESM
-export const notSerializable = "not-serializable";

package/dist/core/processing/serializers/replaceWithParserPath.ts

@@ -1,30 +0,0 @@
-export { replacerWithPath };
-export type { Iterable };
-export type { Path };
-
-// https://stackoverflow.com/questions/61681176/json-stringify-replacer-how-to-get-full-path/63957172#63957172
-
-type Path = (string | number)[];
-type Iterable = Record<string, unknown>;
-type Replacer = (
-  this: Iterable,
-  key: string,
-  value: unknown,
-  path: Path,
-) => unknown;
-function replacerWithPath(replacer: Replacer) {
-  const pathMap = new WeakMap<Iterable, Path>();
-  return function (this: Iterable, key: string, value: unknown) {
-    const pathPrevious = pathMap.get(this) ?? [];
-    const path = [...pathPrevious];
-    if (key !== "") {
-      const pathEntry = !Array.isArray(this) ? key : parseInt(key, 10);
-      path.push(pathEntry);
-    }
-    if (isIterable(value)) pathMap.set(value, path);
-    return replacer.call(this, key, value, path);
-  };
-}
-function isIterable(value: unknown): value is Iterable {
-  return value === Object(value);
-}

package/dist/core/processing/serializers/serializePage/PageConfigSerialized.ts

@@ -1,45 +0,0 @@
-export type {
-  ConfigValueSerialized,
-  PageConfigGlobalRuntimeSerialized,
-  PageConfigRuntimeSerialized,
-  ValueSerialized,
-};
-
-import type {
-  ConfigValueComputed,
-  ConfigValueCumulative,
-  ConfigValueStandard,
-  PageConfigRuntime,
-} from "../../../../types/interfaces/page.js";
-
-/** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
-type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, "configValues"> & {
-  /** Config values that are serializable and loaded eagerly such as config.passToClient */
-  configValuesSerialized: Record<string, ConfigValueSerialized>;
-};
-
-type PageConfigGlobalRuntimeSerialized = {
-  configValuesSerialized: Record<string, ConfigValueSerialized>;
-};
-
-type ValueSerialized =
-  | {
-      type: "js-serialized";
-      value: unknown;
-    }
-  | {
-      type: "plus-file";
-      exportValues: Record<string, unknown>;
-    }
-  | {
-      type: "pointer-import";
-      value: unknown;
-    };
-
-/** Value is serialized */
-type ConfigValueSerialized =
-  | (Omit<ConfigValueStandard, "value"> & { valueSerialized: ValueSerialized })
-  | (Omit<ConfigValueCumulative, "value"> & {
-      valueSerialized: ValueSerialized[];
-    })
-  | (Omit<ConfigValueComputed, "value"> & { valueSerialized: ValueSerialized });

package/dist/core/processing/serializers/serializePage/parsePageConfigs.ts

@@ -1,223 +0,0 @@
-export { parseConfigValuesSerialized, parsePageConfigs }
-
-import type {
-  ConfigValue,
-  ConfigValues,
-  DefinedAtFile,
-  PageConfigGlobalRuntime,
-  PageConfigRuntime,
-} from "../../../../types/interfaces/page.js"
-import type {
-  PageConfigGlobalRuntimeSerialized,
-  PageConfigRuntimeSerialized,
-  ValueSerialized,
-} from "./PageConfigSerialized.js"
-
-import { getConfigDefinedAt } from "../../getters/getConfigDefinedAt.js"
-import type { ConfigValueSerialized } from "./PageConfigSerialized.js"
-// import { parseTransform } from "@brillout/json-serializer/parse";
-import pc from "@brillout/picocolors"
-import { assert } from "../../../gaurds/assertions/assert/index.js"
-import { assertPlusFileExport } from "../../../gaurds/assertions/assertPlusFileExport.js"
-import { assertUsage } from "../../../gaurds/assertions/assertUsage/index.js"
-import { isCallable } from "../../../gaurds/validators/isCallable.js"
-import { parseTransform } from "../../parsers/parseTransform.js"
-
-function parseConfigValuesSerialized(
-  configValuesSerialized: Record<string, ConfigValueSerialized>
-): ConfigValues {
-  const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized)
-  return configValues
-}
-
-function parsePageConfigs(
-  pageConfigsSerialized: PageConfigRuntimeSerialized[],
-  pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized
-): {
-  pageConfigs: PageConfigRuntime[]
-  pageConfigGlobal: PageConfigGlobalRuntime
-} {
-  // pageConfigs
-  const pageConfigs: PageConfigRuntime[] = pageConfigsSerialized.map(
-    (pageConfigSerialized) => {
-      const configValues = parseConfigValuesSerialized(
-        pageConfigSerialized.configValuesSerialized
-      )
-      const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } =
-        pageConfigSerialized
-      assertRouteConfigValue(configValues)
-      return {
-        pageId,
-        isErrorPage,
-        routeFilesystem,
-        configValues,
-        loadConfigValuesAll,
-      } satisfies PageConfigRuntime
-    }
-  )
-
-  // pageConfigsGlobal
-  const pageConfigGlobal: PageConfigGlobalRuntime = { configValues: {} }
-  {
-    const configValues = parseConfigValuesSerialized(
-      pageConfigGlobalSerialized.configValuesSerialized
-    )
-    Object.assign(pageConfigGlobal.configValues, configValues)
-  }
-
-  return { pageConfigs, pageConfigGlobal }
-}
-
-function assertRouteConfigValue(configValues: ConfigValues) {
-  const configName = "route"
-  const configValue = configValues[configName]
-  if (!configValue) return
-  const { value, definedAtData } = configValue
-  const configValueType = typeof value
-  assert(definedAtData)
-  const configDefinedAt = getConfigDefinedAt(
-    "Config",
-    configName,
-    definedAtData
-  )
-  assertUsage(
-    configValueType === "string" || isCallable(value),
-    `${configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://reveal.dev/route`
-  )
-  /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
-  * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.
-  * - assertRouteString() is already called on the server-side
-  * - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
- if (typeof configValue === 'string') {
-   assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
- }
- */
-}
-
-function parseConfigValuesSerialized_tmp(
-  configValuesSerialized: Record<string, ConfigValueSerialized>
-): ConfigValues {
-  const configValues: ConfigValues = {}
-
-  Object.entries(configValuesSerialized).forEach(
-    ([configName, configValueSeriliazed]) => {
-      let configValue: ConfigValue
-      if (configValueSeriliazed.type === "cumulative") {
-        const { valueSerialized, ...common } = configValueSeriliazed
-        const value = valueSerialized.map((valueSerializedElement, i) => {
-          const { value, sideExports } = parseValueSerialized(
-            valueSerializedElement,
-            configName,
-            () => {
-              const definedAtFile = configValueSeriliazed.definedAtData[i]
-              assert(definedAtFile)
-              return definedAtFile
-            }
-          )
-          addSideExports(sideExports)
-          return value
-        })
-        configValue = { value, ...common }
-      } else {
-        const { valueSerialized, ...common } = configValueSeriliazed
-        const { value, sideExports } = parseValueSerialized(
-          valueSerialized,
-          configName,
-          () => {
-            assert(configValueSeriliazed.type !== "computed")
-            return configValueSeriliazed.definedAtData
-          }
-        )
-        addSideExports(sideExports)
-        configValue = { value, ...common }
-      }
-      configValues[configName] = configValue
-    }
-  )
-
-  return configValues
-
-  function addSideExports(sideExports: SideExport[]) {
-    sideExports.forEach((sideExport) => {
-      const { configName, configValue } = sideExport
-      if (!configValues[configName]) {
-        configValues[configName] = configValue
-      } else {
-        // Side-exports have lower precedence.
-        // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
-      }
-    })
-  }
-}
-
-type SideExport = {
-  configName: string
-  configValue: ConfigValue
-}
-function parseValueSerialized(
-  valueSerialized: ValueSerialized,
-  configName: string,
-  getDefinedAtFile: () => DefinedAtFile
-): { value: unknown; sideExports: SideExport[] } {
-  if (valueSerialized.type === "js-serialized") {
-    let { value } = valueSerialized
-    value = parseTransform(value)
-    return { value, sideExports: [] }
-  }
-  if (valueSerialized.type === "pointer-import") {
-    const { value } = valueSerialized
-    return { value, sideExports: [] }
-  }
-  if (valueSerialized.type === "plus-file") {
-    const definedAtFile = getDefinedAtFile()
-    const { exportValues } = valueSerialized
-    assertPlusFileExport(
-      exportValues,
-      definedAtFile.filePathToShowToUser,
-      configName
-    )
-    let value: unknown
-    let valueWasFound = false
-    const sideExports: SideExport[] = []
-    Object.entries(exportValues).forEach(([exportName, exportValue]) => {
-      const isSideExport = exportName !== "default" && exportName !== configName
-      if (!isSideExport) {
-        value = exportValue
-        assert(!valueWasFound)
-        valueWasFound = true
-      } else {
-        sideExports.push({
-          configName: exportName,
-          configValue: {
-            type: "standard", // We don't support side exports for cumulative values. We could support it but it isn't trivial.
-            value: exportValue,
-            definedAtData: {
-              filePathToShowToUser: definedAtFile.filePathToShowToUser,
-              fileExportPathToShowToUser: [exportName],
-            },
-          },
-        })
-      }
-    })
-    // Already validated by assertPlusFileExport() call above.
-    assert(valueWasFound)
-    return { value, sideExports }
-  }
-  assert(false)
-}
-
-/* [NULL_HANDLING] Do we really need this? */
-function assertIsNotNull(
-  configValue: unknown,
-  configName: string,
-  filePathToShowToUser: string
-) {
-  assert(!filePathToShowToUser.includes("+config."))
-  // Re-use this for:
-  //  - upcoming config.requestPageContextOnNavigation
-  //  - for cumulative values in the future: we don't need this for now because, currently, cumulative values are never imported.
-  assertUsage(
-    configValue !== null,
-    `Set ${pc.cyan(configName)} to ${pc.cyan("null")} in a +config.js file instead of ${filePathToShowToUser}`
-  )
-}