@prismicio/types-internal 0.1.0

package/src/customtypes/widgets/slices/Slice.ts

@@ -0,0 +1,7 @@
+import SharedSlice from "./SharedSlice";
+import CompositeSlice from "./CompositeSlice";
+import LegacySlice from "./LegacySlice";
+import SharedSliceRef from "./SharedSliceRef";
+
+export type DynamicSlice = CompositeSlice | LegacySlice | SharedSliceRef
+export type StaticSlice = CompositeSlice | LegacySlice | SharedSlice

package/src/customtypes/widgets/slices/Slices.ts

@@ -0,0 +1,100 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+import { Format } from '../../Format'
+import LegacySlice from './LegacySlice'
+import CompositeSlice from './CompositeSlice'
+import SharedSliceRef from './SharedSliceRef'
+import SharedSlice from './SharedSlice'
+import SlicesTypes from './SlicesTypes'
+
+const SlicesLabels = t.union([
+  t.record(
+    t.string,
+    t.array(
+      t.exact(
+        t.intersection([
+          t.type({
+            name: t.string
+          }),
+          t.partial({
+            display: t.string
+          })
+        ])
+      )
+    )
+  ),
+  t.null
+])
+type SlicesLabels = t.TypeOf<typeof SlicesLabels>
+
+export function slicesConfigReader<F extends Format>(format: F) {
+  return t.exact(
+    t.partial({
+      label: StringOrNull,
+      labels: SlicesLabels,
+      choices: t.record(t.string, t.union([
+        LegacySlice,
+        CompositeSlice,
+        (() => {
+          switch(format) {
+            case Format.Static: return SharedSlice
+            case Format.Dynamic: return SharedSliceRef
+            default: throw new Error(`Invalid Format Exception: ${format} doesn't exist`)
+          }
+        })()
+      ]))
+    })
+  )
+}
+export const StaticSlicesConfig = slicesConfigReader(Format.Static)
+export type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>
+
+export const DynamicSlicesConfig = slicesConfigReader(Format.Dynamic)
+export type DynamicSlicesConfig = t.TypeOf<typeof DynamicSlicesConfig>
+
+const SlicesConfig = {
+  toStatic(config: DynamicSlicesConfig, sharedSlices: Map<string, SharedSlice>): StaticSlicesConfig {
+    const choices: {[key: string]: LegacySlice | CompositeSlice | SharedSlice } = Object.entries(config.choices || {})
+      .reduce((acc, [ref, slice]) => {
+        if(slice.type === SlicesTypes.SharedSlice) {
+          const sharedSlice = sharedSlices.get(ref)
+          if(sharedSlice) return { ...acc, [ref]: sharedSlice }
+          else return acc
+        } else {
+          return { ...acc, [ref]: slice }
+        }
+      }, {})
+  
+    return { ...config, choices } as StaticSlicesConfig
+  }
+}
+
+export function slicesReader<F extends Format>(format: F) {
+  return t.exact(
+    t.intersection([
+      t.type({
+        type: t.union([t.literal(WidgetTypes.Slices), t.literal(WidgetTypes.LegacySlices)])
+      }),
+      t.partial({
+        fieldset: StringOrNull,
+        config: slicesConfigReader(format)
+      })
+    ])
+  )
+}
+
+export const StaticSlices = slicesReader(Format.Static)
+export type StaticSlices = t.TypeOf<typeof StaticSlices>
+
+export const DynamicSlices = slicesReader(Format.Dynamic)
+export type DynamicSlices = t.TypeOf<typeof DynamicSlices>
+
+export const Slices = {
+  toStatic(slices: DynamicSlices, sharedSlices: Map<string, SharedSlice>): StaticSlices {
+    if(!slices.config) return slices as StaticSlices
+    else {
+      return { ...slices, config: SlicesConfig.toStatic(slices.config, sharedSlices) }
+    }
+  }
+}

package/src/customtypes/widgets/slices/SlicesTypes.ts

@@ -0,0 +1,6 @@
+enum SlicesTypes {
+  Slice = 'Slice',
+  SharedSlice = 'SharedSlice'
+}
+
+export default SlicesTypes

package/src/customtypes/widgets/slices/index.ts

@@ -0,0 +1,7 @@
+export { default as CompositeSlice } from './CompositeSlice'
+export { default as LegacySlice } from './LegacySlice'
+export { default as SharedSlice } from './SharedSlice'
+export { default as SharedSliceRef } from './SharedSliceRef'
+export { default as SlicesTypes } from './SlicesTypes'
+export * as Slice from './Slice'
+export * as SliceZone from './Slices'

package/src/index.ts

@@ -0,0 +1 @@
+export * as CustomTypes from './customtypes'

package/src/validators/IntFromNumber.ts

@@ -0,0 +1,24 @@
+ import * as t from 'io-ts'
+ import { pipe } from 'fp-ts/lib/pipeable'
+ import { chain } from 'fp-ts/lib/Either'
+ 
+ export interface IntFromNumberC extends t.Type<t.Int, number, unknown> {}
+ 
+ /**
+  * A codec that succeeds if a number can be parsed to an integer
+  */
+ export const IntFromNumber: IntFromNumberC = new t.Type<t.Int, number, unknown>(
+   'IntFromNumber',
+   t.Int.is,
+   (u, c) =>
+     pipe(
+       t.number.validate(u, c),
+       chain(n => {
+         if(t.Int.is(n)) return t.success(n)
+         else {
+          return t.success(Math.round(n) as t.Int)
+         }
+       })
+     ),
+     t.Int.encode
+ )

package/src/validators/IntFromPixels.ts

@@ -0,0 +1,31 @@
+import * as t from 'io-ts'
+import { pipe } from 'fp-ts/lib/pipeable'
+import { chain } from 'fp-ts/lib/Either'
+
+export interface IntFromPixelsC extends t.Type<t.Int, string, unknown> {}
+
+const PixelsRegex = /^([0-9]+)px$/
+/**
+ * A codec that succeeds if a string representing pixels (eg: "200px") can be parsed to an integer
+ */
+export const IntFromPixels: IntFromPixelsC = new t.Type<t.Int, string, unknown>(
+  'IntFromPixels',
+  t.Int.is,
+  (u, c) =>
+    pipe(
+      t.string.validate(u, c),
+      chain(strPixels => {
+        try {
+          const matched = strPixels.match(PixelsRegex)
+          if(!matched) return t.failure(u, c)
+          else {
+            const parsed = parseInt(matched[1]) as t.Int
+            return t.success(parsed)
+          }
+        } catch {
+          return t.failure(u, c)
+        }
+      })
+    ),
+    String
+)

package/src/validators/StringFromBoolean.ts

@@ -0,0 +1,21 @@
+import * as t from 'io-ts'
+import { pipe } from 'fp-ts/lib/pipeable'
+import { chain } from 'fp-ts/lib/Either'
+
+export interface StringFromBooleanC extends t.Type<string, string, unknown> {}
+
+/**
+ * A codec that validates a Boolean and convert it as a string
+ */
+export const StringFromBoolean: StringFromBooleanC = new t.Type<string, string, unknown>(
+  'StringFromInt',
+  t.string.is,
+  (u, c) =>
+    pipe(
+      t.boolean.validate(u, c),
+      chain(i => {
+        return t.success(i.toString())
+      })
+    ),
+    i => i
+)

package/src/validators/StringFromNumber.ts

@@ -0,0 +1,21 @@
+import * as t from 'io-ts'
+import { pipe } from 'fp-ts/lib/pipeable'
+import { chain } from 'fp-ts/lib/Either'
+
+export interface StringFromNumberC extends t.Type<string, string, unknown> {}
+
+/**
+ * A codec that validates a number and convert it as a string
+ */
+export const StringFromNumber: StringFromNumberC = new t.Type<string, string, unknown>(
+  'StringFromInt',
+  t.string.is,
+  (u, c) =>
+    pipe(
+      t.number.validate(u, c),
+      chain(i => {
+        return t.success(i.toString())
+      })
+    ),
+    i => i
+)

package/src/validators/StringOrNull.ts

@@ -0,0 +1,3 @@
+import * as t from 'io-ts'
+
+export const StringOrNull = t.union([ t.string, t.null, t.undefined ])