Proposal : Linking API

[Freddy03h]

Linking API

For my project I created a linking API but I'm far from zero cost binding, since ReScript 10 and optional record attribute, it's seems less shitty and I think it's cool to discuss to have experts opinions about it.

Proposal

type routeName = string

type rec pathConfig = {
  path?: string,
  exact?: bool,
  initialRouteName?: routeName,
  screens?: screens,
}
and screens = Js.Dict.t<pathConfig>

type config = {
  initialRouteName?: routeName,
  screens: screens,
}

type t = {
  enabled?: bool,
  prefixes: array<string>,
  config?: config,
}

type routeNameAndConfig = (routeName, pathConfig)

let makeScreens = (screens: array<routeNameAndConfig>): screens => screens->Js.Dict.fromArray

Example

let options = {
  prefixes: [WebConst.origin],
  config: {
    initialRouteName: "app",
    screens: [
      (
        "app",
        {
          screens: [
            ("news", {screens: [("newsList", {path: ""})]->makeScreens}),
            (
              "planning",
              {
                screens: [
                  (
                    "planningNav",
                    {
                      screens: [
                        ("planningNewList", {path: "planning/news"}),
                        ("planningList", {path: "planning"}),
                      ]->makeScreens,
                    },
                  ),
                ]->makeScreens,
              },
            ),
            (
              "catalogue",
              {
                screens: [
                  (
                    "catalogueNav",
                    {
                      screens: [
                        ("seriesList", {path: "series"}),
                        ("authorsList", {path: "authors"}),
                        ("publishersList", {path: "publishers"}),
                      ]->makeScreens,
                    },
                  ),
                ]->makeScreens,
              },
            ),
          ]->makeScreens,
        },
      ),
      (
        "modalNav",
        {
          screens: [
            ("volumeDetail", {path: "volumes/:id"}),
            ("editionDetail", {path: "editions/:id"}),
            ("serieDetail", {path: "series/:id"}),
            ("publisherDetail", {path: "publishers/:id"}),
            ("authorDetail", {path: "authors/:id"}),
          ]->makeScreens,
        },
      ),
      (
        "collectionPublic",
        {
          initialRouteName: "collectionPublicNav",
          path: "user/:username",
          screens: [
            (
              "collectionPublicNav",
              {
                screens: [
                  ("collectionPublicList", {path: "collection"}),
                  ("planningPersoPublicList", {path: "planning"}),
                  ("missingPublicList", {path: "missing"}),
                  ("wishPublicList", {path: "wish"}),
                ]->makeScreens,
              },
            ),
            ("collectionPublicEdition", {path: "edition/:editionId"}),
          ]->makeScreens,
        },
      ),
    ]->makeScreens,
  },
}

[MoOx]

Is there a real interest to define screens = Js.Dict.t<pathConfig> ?
If that's a abstract type (type screens;) makeScreen could be zero cost, right ?

[Freddy03h]

I don't know how to do that…

If screens isn't defined, it seems compiler take the first declared definition of screens and made others as errors.

[MoOx]

Is this needed with #58 ?

[Freddy03h]

Linking is not blocking for a new release, because this API doesn't exist yet.

I tested it on 10.0, I can give a new try with 10.1

[Freddy03h]

This could help us : rescript-lang/rescript#6545

[Freddy03h]

@cknitt Hello, what's your opinion about merging something like that for Linking:

type rec config = {
  path?: string,
  exact?: bool,
  initialRouteName?: string,
  screens?: screens,
}
and screens = Js.Dict.t<config>

type t = {
  enabled?: bool,
  prefixes: array<string>,
  config?: config,
}

that will be used like this for now:

let options = {
  prefixes: ["https://www.mangacollec.com"],
  config: {
    initialRouteName: "app",
    screens: [
      (
        "app",
        {
          screens: [
            (
              "news",
              {
                screens: [("newsList", {path: ""})]->Js.Dict.fromArray,
              },
            ),
          ]->Js.Dict.fromArray,
        },
      ),
    ]->Js.Dict.fromArray,
  },
}

it's not zero cost but it will be with the dict{} syntax in rescript 12, without changing the types

let options = {
  prefixes: ["https://www.mangacollec.com"],
  config: {
    initialRouteName: "app",
    screens: dict{
      "app": {
        screens: dict{
          "news": {
            screens: dict{
              "newsList": {path: ""},
            },
          },
        },
      },
    },
  },
}

It could be used now without waiting.

[cknitt]

Not using Linking in our apps, but this looks good to me! 👍