Resi

Author: fhammerschmidt

packages/dev-playground/src/CompilerApi.res

@@ -48,9 +48,8 @@ type failure = {
   time: float,
 }
 
-type formatResult =
-  | Formatted(string)
-  | FormatFailed(failure)
+type compileResult = result<success, failure>
+type formatResult = result<string, failure>
 
 type normalizedConfig = {
   moduleSystem: PlaygroundConfig.moduleSystem,
@@ -266,8 +265,6 @@ let failureFromCompileOutput = (compileOutput, elapsedMs): failure => {
   {errors, warnings, message, time: elapsedMs}
 }
 
-type compileResult = result<success, failure>
-
 let normalize = (compileOutput, elapsedMs): compileResult => {
   switch (
     compileOutput->CompileResult.parsetree,
@@ -454,16 +451,16 @@ let format = async (source, config: PlaygroundConfig.t) => {
 
   if formatOutput->resultIsSuccess {
     switch formatOutput->CompileResult.code {
-    | Some(code) => Formatted(code)
+    | Some(code) => Ok(code)
     | None =>
-      FormatFailed({
+      Error({
         errors: [],
         warnings: [],
         message: "Formatting did not return code",
         time: elapsedMs,
       })
     }
   } else {
-    FormatFailed(failureFromCompileOutput(formatOutput, elapsedMs))
+    Error(failureFromCompileOutput(formatOutput, elapsedMs))
   }
 }

packages/dev-playground/src/CompilerApi.resi

@@ -0,0 +1,47 @@
+module Version: {
+  type t = {
+    id: string,
+    label: string,
+  }
+}
+
+type info = {
+  bundleId: string,
+  version: string,
+  apiVersion: string,
+  moduleSystem: PlaygroundConfig.moduleSystem,
+  warnFlags: string,
+  jsxPreserveMode: bool,
+  experimentalFeatures: array<PlaygroundConfig.experimentalFeature>,
+  libraries: array<string>,
+}
+
+type success = {
+  jsCode: string,
+  parsetree: string,
+  typedtree: string,
+  lambda: string,
+  lam: string,
+  warnings: array<string>,
+  time: float,
+}
+
+type failure = {
+  errors: array<string>,
+  warnings: array<string>,
+  message: string,
+  time: float,
+}
+
+let defaultWarnFlags: string
+let defaultCompilerVersion: string
+let availableCompilerVersions: array<Version.t>
+
+type compileResult = result<success, failure>
+type formatResult = result<string, failure>
+
+let init: string => promise<info>
+
+let compile: (string, PlaygroundConfig.t) => promise<compileResult>
+
+let format: (string, PlaygroundConfig.t) => promise<formatResult>

packages/dev-playground/src/Main.res

@@ -60,7 +60,7 @@ let jsErrorMessage = obj =>
   | None => "Unknown JavaScript error"
   }
 
-let insertTabIndent = (event: Dom.event): option<string> => {
+let insertTabIndent = (event: Dom.event): option<string> =>
   if event->Event.key !== "Tab" {
     None
   } else {
@@ -78,9 +78,8 @@ let insertTabIndent = (event: Dom.event): option<string> => {
 
     Some(nextValue)
   }
-}
 
-let configureSourceEditor = (scrollHandler: Dom.event => unit): unit => {
+let configureSourceEditor = (scrollHandler: Dom.event => unit): unit =>
   Window.requestAnimationFrame(() =>
     switch Document.current->Document.getElementById("source-editor") {
     | None => ()
@@ -98,7 +97,6 @@ let configureSourceEditor = (scrollHandler: Dom.event => unit): unit => {
       }
     }
   )
-}
 
 let lineNumbersText = source => {
   let lineCount = source->String.split("\n")->Array.length
@@ -596,12 +594,14 @@ module App = {
   @jsx.component
   let make = () => {
     let requestedCompilerVersion = UrlState.queryCompilerVersion(CompilerApi.defaultCompilerVersion)
+
     let initialCompilerVersion =
       CompilerApi.availableCompilerVersions->Array.some(version =>
         version.id === requestedCompilerVersion
       )
         ? requestedCompilerVersion
         : CompilerApi.defaultCompilerVersion
+
     let initialModuleSystem = UrlState.queryModuleSystem(Esmodule)
     let initialWarnFlags = UrlState.queryWarnFlags(CompilerApi.defaultWarnFlags)
     let initialJsxPreserveMode = UrlState.queryJsxPreserveMode(false)
@@ -636,6 +636,7 @@ module App = {
     let syncEditorState = event => {
       let currentSource = Event.value(event)
       let cursorPosition = cursorPositionForOffset(currentSource, Event.selectionStart(event))
+
       Signal.set(editorScrollTop, Event.scrollTop(event))
       Signal.set(editorScrollLeft, Event.scrollLeft(event))
       Signal.set(activeLine, cursorPosition.line)
@@ -694,16 +695,15 @@ module App = {
       timerId := Some(Window.setTimeout(compileNow, 280))
     }
 
-    let syncUrlNow = () => {
+    let syncUrlNow = () =>
       UrlState.replaceUrlState(
-        Signal.peek(source),
-        Signal.peek(compilerVersion),
-        Signal.peek(moduleSystem),
-        Signal.peek(warnFlags),
-        Signal.peek(jsxPreserveMode),
-        Signal.peek(experimentalFeatures),
-      )->ignore
-    }
+        ~source=Signal.peek(source),
+        ~compilerVersion=Signal.peek(compilerVersion),
+        ~moduleSystem=Signal.peek(moduleSystem),
+        ~warnFlags=Signal.peek(warnFlags),
+        ~jsxPreserveMode=Signal.peek(jsxPreserveMode),
+        ~experimentalFeatures=Signal.peek(experimentalFeatures),
+      )->Promise.ignore
 
     let scheduleUrlSync = () => {
       switch urlTimerId.contents {
@@ -726,7 +726,7 @@ module App = {
           Signal.set(status, Compiling)
           try {
             switch await CompilerApi.format(sourceBeforeFormat, currentConfig()) {
-            | Formatted(formattedSource) =>
+            | Ok(formattedSource) =>
               if sequence === compileSequence.contents {
                 if Signal.peek(source) === sourceBeforeFormat {
                   Signal.set(source, formattedSource)
@@ -740,7 +740,7 @@ module App = {
                   Signal.set(status, Ready)
                 }
               }
-            | FormatFailed(failure) =>
+            | Error(failure) =>
               if sequence === compileSequence.contents {
                 Signal.set(compileResult, Some(Error(failure)))
                 Signal.set(status, Ready)
@@ -779,12 +779,12 @@ module App = {
 
       let share = async () => {
         switch await UrlState.copyUrlState(
-          Signal.peek(source),
-          Signal.peek(compilerVersion),
-          Signal.peek(moduleSystem),
-          Signal.peek(warnFlags),
-          Signal.peek(jsxPreserveMode),
-          Signal.peek(experimentalFeatures),
+          ~source=Signal.peek(source),
+          ~compilerVersion=Signal.peek(compilerVersion),
+          ~moduleSystem=Signal.peek(moduleSystem),
+          ~warnFlags=Signal.peek(warnFlags),
+          ~jsxPreserveMode=Signal.peek(jsxPreserveMode),
+          ~experimentalFeatures=Signal.peek(experimentalFeatures),
         ) {
         | Ok() => showToast("Link copied")
         | Error(message) => showToast(message)

packages/dev-playground/src/UrlState.res

@@ -1,5 +1,3 @@
-open PlaygroundConfig
-
 let maxEncodedCodeLength = 300 * 1024
 let maxDecodedSourceLength = 200 * 1024
 let replaceSequence = ref(0)
@@ -8,16 +6,13 @@ let getParam = name => {
   UrlSearchParams.make(Location.search)->UrlSearchParams.get(name)
 }
 
-let encodeCode = SharedCode.encode
-let decodeCode = SharedCode.decode
-
 let applyUrlState = (
-  encoded,
-  compilerVersion,
-  moduleSystem: moduleSystem,
-  warnFlags,
-  jsxPreserveMode,
-  experimentalFeatures: array<experimentalFeature>,
+  ~encoded,
+  ~compilerVersion,
+  ~moduleSystem: PlaygroundConfig.moduleSystem,
+  ~warnFlags,
+  ~jsxPreserveMode,
+  ~experimentalFeatures: array<PlaygroundConfig.experimentalFeature>,
 ) => {
   let moduleSystem = (moduleSystem :> string)
   let experimentalFeatures = experimentalFeatures->Array.map(feature => (feature :> string))
@@ -50,7 +45,7 @@ let initialSource = async defaultSource => {
   | Some(encoded)
     if encoded === "" || encoded->String.length > maxEncodedCodeLength => defaultSource
   | Some(encoded) =>
-    switch await decodeCode(encoded) {
+    switch await SharedCode.decode(encoded) {
     | decoded => decoded->String.length <= maxDecodedSourceLength ? decoded : defaultSource
     | exception error =>
       Console.warn2("Could not restore shared playground source", error)
@@ -68,7 +63,7 @@ let queryCompilerVersion = defaultVersion =>
 let queryModuleSystem = defaultModuleSystem =>
   switch getParam("module") {
   | Some(value) =>
-    switch value->parseModuleSystem {
+    switch value->PlaygroundConfig.parseModuleSystem {
     | Some(moduleSystem) => moduleSystem
     | None => defaultModuleSystem
     }
@@ -90,47 +85,48 @@ let queryJsxPreserveMode = defaultValue =>
 let queryExperimentalFeatures = () =>
   switch getParam("experimental") {
   | Some(value) if value !== "" =>
-    value->String.split(",")->Array.filterMap(parseExperimentalFeature)
+    value->String.split(",")->Array.filterMap(PlaygroundConfig.parseExperimentalFeature)
   | _ => []
   }
 
 let replaceUrlState = async (
-  source,
-  compilerVersion,
-  moduleSystem,
-  warnFlags,
-  jsxPreserveMode,
-  experimentalFeatures,
+  ~source,
+  ~compilerVersion,
+  ~moduleSystem,
+  ~warnFlags,
+  ~jsxPreserveMode,
+  ~experimentalFeatures,
 ) => {
   replaceSequence := replaceSequence.contents + 1
   let sequence = replaceSequence.contents
-  let encoded = await encodeCode(source)
+  let encoded = await SharedCode.encode(source)
+
   if sequence === replaceSequence.contents {
     applyUrlState(
-      encoded,
-      compilerVersion,
-      moduleSystem,
-      warnFlags,
-      jsxPreserveMode,
-      experimentalFeatures,
+      ~encoded,
+      ~compilerVersion,
+      ~moduleSystem,
+      ~warnFlags,
+      ~jsxPreserveMode,
+      ~experimentalFeatures,
     )
   }
 }
 
 let windowHref = () => Location.href
 
 let copyUrlState = async (
-  source,
-  compilerVersion,
-  moduleSystem,
-  warnFlags,
-  jsxPreserveMode,
-  experimentalFeatures,
+  ~source,
+  ~compilerVersion,
+  ~moduleSystem,
+  ~warnFlags,
+  ~jsxPreserveMode,
+  ~experimentalFeatures,
 ): result<unit, string> => {
   replaceSequence := replaceSequence.contents + 1
   let sequence = replaceSequence.contents
 
-  let? Ok(encoded) = switch await encodeCode(source) {
+  let? Ok(encoded) = switch await SharedCode.encode(source) {
   | encoded => Ok(encoded)
   | exception _ => Error("Could not copy link")
   }
@@ -139,12 +135,12 @@ let copyUrlState = async (
     Error("Link changed before it could be copied")
   } else {
     applyUrlState(
-      encoded,
-      compilerVersion,
-      moduleSystem,
-      warnFlags,
-      jsxPreserveMode,
-      experimentalFeatures,
+      ~encoded,
+      ~compilerVersion,
+      ~moduleSystem,
+      ~warnFlags,
+      ~jsxPreserveMode,
+      ~experimentalFeatures,
     )
 
     let href = windowHref()

packages/dev-playground/src/UrlState.resi

@@ -0,0 +1,29 @@
+let initialSource: string => promise<string>
+
+let queryCompilerVersion: string => string
+
+let queryModuleSystem: PlaygroundConfig.moduleSystem => PlaygroundConfig.moduleSystem
+
+let queryWarnFlags: string => string
+
+let queryJsxPreserveMode: bool => bool
+
+let queryExperimentalFeatures: unit => array<PlaygroundConfig.experimentalFeature>
+
+let replaceUrlState: (
+  ~source: string,
+  ~compilerVersion: string,
+  ~moduleSystem: PlaygroundConfig.moduleSystem,
+  ~warnFlags: string,
+  ~jsxPreserveMode: bool,
+  ~experimentalFeatures: array<PlaygroundConfig.experimentalFeature>,
+) => promise<unit>
+
+let copyUrlState: (
+  ~source: string,
+  ~compilerVersion: string,
+  ~moduleSystem: PlaygroundConfig.moduleSystem,
+  ~warnFlags: string,
+  ~jsxPreserveMode: bool,
+  ~experimentalFeatures: array<PlaygroundConfig.experimentalFeature>,
+) => promise<result<unit, string>>