@prismicio/types-internal 0.1.1 → 0.2.3

package/lib/documents/widgets/nestable/FieldContent.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldContentType = void 0;
+const tslib_1 = require("tslib");
+const function_1 = require("fp-ts/function");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.FieldContentType = "FieldContent";
+//we do that instead of idiomatic .trim()
+//because we need to have the exact same behaviour than scala/java .trim()
+//in other world only trim space and not non-breaking space or tab
+function trimScalaStyle(s) {
+    let startAt = 0;
+    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+    while (startAt < s.length && s[startAt] <= " ") {
+        startAt++;
+    }
+    let endAt = s.length;
+    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+    while (startAt < endAt && s[endAt - 1] <= " ") {
+        endAt--;
+    }
+    return s.substring(startAt, endAt);
+}
+const FieldContent = {
+    types: ["Text", "Date", "Timestamp", "Color", "Number", "Range", "Select"],
+    forType: (type, value) => {
+        return (0, function_1.pipe)(O.fromEither(t.string.decode(value)), O.map((r) => {
+            return {
+                value: trimScalaStyle(r),
+                type,
+                __TYPE__: "FieldContent",
+            };
+        }));
+    },
+};
+exports.default = FieldContent;

package/lib/documents/widgets/nestable/GeoPointContent.d.ts

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const GeoPointContentType = "GeoPointContent";
+export declare const GeoPointContent: t.Type<{
+    position: {
+        lat: number;
+        lng: number;
+    };
+}, {
+    position: {
+        lat: number;
+        lng: number;
+    };
+} & {
+    __TYPE__: "GeoPointContent";
+}, unknown>;
+export declare type GeoPointContent = t.TypeOf<typeof GeoPointContent>;
+export declare type GeoPointContentO = t.OutputOf<typeof GeoPointContent>;

package/lib/documents/widgets/nestable/GeoPointContent.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoPointContent = exports.GeoPointContentType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../validators/function");
+exports.GeoPointContentType = "GeoPointContent";
+exports.GeoPointContent = (0, function_1.addType)(t.strict({
+    position: t.strict({
+        lat: t.number,
+        lng: t.number,
+    }),
+}), exports.GeoPointContentType);

package/lib/documents/widgets/nestable/ImageContent.d.ts

@@ -0,0 +1,127 @@
+import * as t from "io-ts";
+export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
+    origin: t.ExactC<t.TypeC<{
+        id: t.StringC;
+        url: t.StringC;
+        width: t.NumberC;
+        height: t.NumberC;
+    }>>;
+    width: t.NumberC;
+    height: t.NumberC;
+    edit: t.TypeC<{
+        zoom: t.NumberC;
+        crop: t.TypeC<{
+            x: t.NumberC;
+            y: t.NumberC;
+        }>;
+        background: t.StringC;
+    }>;
+}>, t.PartialC<{
+    url: t.StringC;
+    credits: t.Type<string | null, string | null, unknown>;
+    alt: t.Type<string | null, string | null, unknown>;
+    provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type ImageContentView = t.TypeOf<typeof ImageContentView>;
+export declare const ImageContentType = "ImageContent";
+export declare const ImageContent: t.Type<{
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string;
+    credits?: string | null;
+    alt?: string | null;
+    provider?: string | null | undefined;
+} & {
+    thumbnails?: {
+        [x: string]: {
+            origin: {
+                id: string;
+                url: string;
+                width: number;
+                height: number;
+            };
+            width: number;
+            height: number;
+            edit: {
+                zoom: number;
+                crop: {
+                    x: number;
+                    y: number;
+                };
+                background: string;
+            };
+        } & {
+            url?: string;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | undefined;
+        };
+    };
+}, {
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string;
+    credits?: string | null;
+    alt?: string | null;
+    provider?: string | null | undefined;
+} & {
+    thumbnails?: {
+        [x: string]: {
+            origin: {
+                id: string;
+                url: string;
+                width: number;
+                height: number;
+            };
+            width: number;
+            height: number;
+            edit: {
+                zoom: number;
+                crop: {
+                    x: number;
+                    y: number;
+                };
+                background: string;
+            };
+        } & {
+            url?: string;
+            credits?: string | null;
+            alt?: string | null;
+            provider?: string | null | undefined;
+        };
+    };
+} & {
+    __TYPE__: "ImageContent";
+}, unknown>;
+export declare type ImageContent = t.TypeOf<typeof ImageContent>;
+export declare type ImageContentO = t.OutputOf<typeof ImageContent>;

package/lib/documents/widgets/nestable/ImageContent.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageContent = exports.ImageContentType = exports.ImageContentView = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_1 = require("../../../validators/function");
+const Origin = t.exact(t.type({
+    id: t.string,
+    url: t.string,
+    width: t.number,
+    height: t.number,
+}));
+exports.ImageContentView = t.exact(t.intersection([
+    t.type({
+        origin: Origin,
+        width: t.number,
+        height: t.number,
+        edit: t.type({
+            zoom: t.number,
+            crop: t.type({
+                x: t.number,
+                y: t.number,
+            }),
+            background: t.string,
+        }),
+    }),
+    t.partial({
+        url: t.string,
+        credits: validators_1.NonEmptyStringOrNull,
+        alt: validators_1.NonEmptyStringOrNull,
+        provider: validators_1.StringOrNull,
+    }),
+]));
+exports.ImageContentType = "ImageContent";
+exports.ImageContent = (0, function_1.addType)(t.intersection([
+    exports.ImageContentView,
+    t.partial({
+        thumbnails: t.record(t.string, exports.ImageContentView),
+    }),
+]), exports.ImageContentType);

package/lib/documents/widgets/nestable/IntegrationFieldsContent.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+declare type IntegrationFieldsContent = {
+    __TYPE__: "IntegrationFieldsContent";
+    value: string;
+};
+export declare const IntegrationFieldsContentType = "IntegrationFieldsContent";
+declare const IntegrationFieldsContent: t.Type<IntegrationFieldsContent, IntegrationFieldsContent, unknown>;
+export default IntegrationFieldsContent;

package/lib/documents/widgets/nestable/IntegrationFieldsContent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationFieldsContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.IntegrationFieldsContentType = "IntegrationFieldsContent";
+const IntegrationFieldsContent = new t.Type("IntegrationFieldsContent", (u) => u?.__TYPE__ === exports.IntegrationFieldsContentType, (u, c) => Either_1.Chain.chain(t.string.validate(u, c), (u) => {
+    return t.success({
+        value: u,
+        __TYPE__: exports.IntegrationFieldsContentType,
+    });
+}), () => {
+    throw new Error("Not implemented - Not used - Not relevant");
+});
+exports.default = IntegrationFieldsContent;

package/lib/documents/widgets/nestable/Link/DocumentLink.d.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+export declare const DocumentLinkType = "DocumentLink";
+export declare const DocumentLink: t.Type<{
+    id: string;
+}, {
+    id: string;
+} & {
+    __TYPE__: "DocumentLink";
+}, unknown>;
+export declare type DocumentLink = t.TypeOf<typeof DocumentLink>;
+export declare type DocumentLinkO = t.OutputOf<typeof DocumentLink>;
+export declare function isDocumentLink(u: unknown): u is DocumentLinkO;

package/lib/documents/widgets/nestable/Link/DocumentLink.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDocumentLink = exports.DocumentLink = exports.DocumentLinkType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+exports.DocumentLinkType = "DocumentLink";
+exports.DocumentLink = (0, function_1.addType)(t.strict({ id: validators_1.NonEmptyString }), exports.DocumentLinkType);
+function isDocumentLink(u) {
+    return u.__TYPE__ === exports.DocumentLinkType;
+}
+exports.isDocumentLink = isDocumentLink;

package/lib/documents/widgets/nestable/Link/ExternalLink.d.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare const ExternalLinkType = "ExternalLink";
+export declare const ExternalLink: t.Type<{
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+}, {
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+} & {
+    __TYPE__: "ExternalLink";
+}, unknown>;
+export declare type ExternalLink = t.TypeOf<typeof ExternalLink>;
+export declare type ExternalLinkO = t.OutputOf<typeof ExternalLink>;
+export declare function isExternalLink(u: unknown): u is ExternalLinkO;

package/lib/documents/widgets/nestable/Link/ExternalLink.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalLink = exports.ExternalLink = exports.ExternalLinkType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+exports.ExternalLinkType = "ExternalLink";
+exports.ExternalLink = (0, function_1.addType)(t.exact(t.intersection([
+    t.type({
+        url: t.string,
+    }),
+    t.partial({
+        kind: t.literal("web"),
+        target: validators_1.StringOrNull,
+        preview: (0, function_1.nullable)(t.partial({
+            title: t.string,
+        })),
+    }),
+])), exports.ExternalLinkType);
+function isExternalLink(u) {
+    return u.__TYPE__ === exports.ExternalLinkType;
+}
+exports.isExternalLink = isExternalLink;

package/lib/documents/widgets/nestable/Link/FileLink.d.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+export declare const FileLinkType = "FileLink";
+export declare const FileLink: t.Type<{
+    id: string;
+    url: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+    size?: string | null | undefined;
+}, {
+    readonly size: string;
+    readonly __TYPE__: "FileLink";
+    readonly id: string;
+    readonly url: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly date?: string | null | undefined;
+}, unknown>;
+export declare type FileLink = t.TypeOf<typeof FileLink>;
+export declare type FileLinkO = t.OutputOf<typeof FileLink>;
+export declare function isFileLink(u: unknown): u is FileLinkO;

package/lib/documents/widgets/nestable/Link/FileLink.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileLink = exports.FileLink = exports.FileLinkType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const mapOutput_1 = require("io-ts-types/lib/mapOutput");
+const function_1 = require("../../../../validators/function");
+exports.FileLinkType = "FileLink";
+exports.FileLink = (0, mapOutput_1.mapOutput)(t.exact(t.intersection([
+    t.type({
+        id: t.string,
+        url: t.string,
+        name: t.string,
+        kind: t.string,
+    }),
+    t.partial({
+        date: (0, function_1.nullable)(t.string),
+        size: (0, function_1.nullable)(t.string),
+    }),
+])), (o) => ({ ...o, size: o.size || "0", __TYPE__: exports.FileLinkType }));
+function isFileLink(u) {
+    return u.__TYPE__ === exports.FileLinkType;
+}
+exports.isFileLink = isFileLink;

package/lib/documents/widgets/nestable/Link/ImageLink.d.ts

@@ -0,0 +1,28 @@
+import * as t from "io-ts";
+export declare const ImageLinkType = "ImageLink";
+export declare const ImageLink: t.Type<{
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+}, {
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+} & {
+    __TYPE__: "ImageLink";
+}, unknown>;
+export declare type ImageLink = t.TypeOf<typeof ImageLink>;
+export declare type ImageLinkO = t.OutputOf<typeof ImageLink>;
+export declare function isImageLink(u: unknown): u is ImageLinkO;

package/lib/documents/widgets/nestable/Link/ImageLink.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageLink = exports.ImageLink = exports.ImageLinkType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+exports.ImageLinkType = "ImageLink";
+exports.ImageLink = (0, function_1.addType)(t.exact(t.intersection([
+    t.type({
+        id: t.string,
+        url: t.string,
+        height: t.string,
+        width: t.string,
+        size: t.string,
+        name: t.string,
+        kind: t.string,
+    }),
+    t.partial({
+        date: validators_1.StringOrNull,
+    }),
+])), exports.ImageLinkType);
+function isImageLink(u) {
+    return u.__TYPE__ === exports.ImageLinkType;
+}
+exports.isImageLink = isImageLink;

package/lib/documents/widgets/nestable/Link/LinkContent.d.ts

@@ -0,0 +1,36 @@
+import * as t from "io-ts";
+import { Link } from "./index";
+export declare type LinkContent = {
+    __TYPE__: "LinkContent";
+    value: Link;
+};
+export declare const LinkContentType = "LinkContent";
+export declare const LinkContent: t.Type<LinkContent, {
+    id: string;
+} | ({
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+}) | ({
+    id: string;
+    url: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+    size?: string | null | undefined;
+}) | ({
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+}), unknown>;

package/lib/documents/widgets/nestable/Link/LinkContent.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkContent = exports.LinkContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const index_1 = require("./index");
+exports.LinkContentType = "LinkContent";
+exports.LinkContent = new t.Type("LinkContent", (u) => {
+    return index_1.Link.is(u?.value);
+}, (u, c) => Either_1.Chain.chain(index_1.Link.validate(u, c), (u) => {
+    return t.success({ value: u, __TYPE__: exports.LinkContentType });
+}), (linkContent) => index_1.Link.encode(linkContent.value));

package/lib/documents/widgets/nestable/Link/index.d.ts

@@ -0,0 +1,89 @@
+import * as t from "io-ts";
+import { isDocumentLink } from "./DocumentLink";
+import { isExternalLink } from "./ExternalLink";
+import { isFileLink } from "./FileLink";
+import { isImageLink } from "./ImageLink";
+export declare const Link: t.UnionC<[t.Type<{
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+}, {
+    id: string;
+    url: string;
+    height: string;
+    width: string;
+    size: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+} & {
+    __TYPE__: "ImageLink";
+}, unknown>, t.Type<{
+    id: string;
+    url: string;
+    name: string;
+    kind: string;
+} & {
+    date?: string | null | undefined;
+    size?: string | null | undefined;
+}, {
+    readonly size: string;
+    readonly __TYPE__: "FileLink";
+    readonly id: string;
+    readonly url: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly date?: string | null | undefined;
+}, unknown>, t.Type<{
+    id: string;
+}, {
+    id: string;
+} & {
+    __TYPE__: "DocumentLink";
+}, unknown>, t.Type<{
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+}, {
+    url: string;
+} & {
+    kind?: "web";
+    target?: string | null | undefined;
+    preview?: {
+        title?: string;
+    } | null | undefined;
+} & {
+    __TYPE__: "ExternalLink";
+}, unknown>]>;
+export declare type Link = t.TypeOf<typeof Link>;
+export declare type LinkO = t.OutputOf<typeof Link>;
+export { type DocumentLinkO, DocumentLink } from "./DocumentLink";
+export { type ExternalLinkO, ExternalLink } from "./ExternalLink";
+export { type FileLinkO, FileLink } from "./FileLink";
+export { type ImageLinkO, ImageLink } from "./ImageLink";
+export { LinkContent } from "./LinkContent";
+export declare const BROKEN_CUSTOM_TYPE = "broken_type";
+export declare const is: {
+    documentLink: typeof isDocumentLink;
+    fileLink: typeof isFileLink;
+    externalLink: typeof isExternalLink;
+    imageLink: typeof isImageLink;
+};
+export declare const LinksTypes: {
+    DocumentLink: string;
+    FileLink: string;
+    ExternalLink: string;
+    ImageLink: string;
+    LinkContent: string;
+};

package/lib/documents/widgets/nestable/Link/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinksTypes = exports.is = exports.BROKEN_CUSTOM_TYPE = exports.LinkContent = exports.ImageLink = exports.FileLink = exports.ExternalLink = exports.DocumentLink = exports.Link = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const DocumentLink_1 = require("./DocumentLink");
+const ExternalLink_1 = require("./ExternalLink");
+const FileLink_1 = require("./FileLink");
+const ImageLink_1 = require("./ImageLink");
+const LinkContent_1 = require("./LinkContent");
+exports.Link = t.union([ImageLink_1.ImageLink, FileLink_1.FileLink, DocumentLink_1.DocumentLink, ExternalLink_1.ExternalLink]);
+var DocumentLink_2 = require("./DocumentLink");
+Object.defineProperty(exports, "DocumentLink", { enumerable: true, get: function () { return DocumentLink_2.DocumentLink; } });
+var ExternalLink_2 = require("./ExternalLink");
+Object.defineProperty(exports, "ExternalLink", { enumerable: true, get: function () { return ExternalLink_2.ExternalLink; } });
+var FileLink_2 = require("./FileLink");
+Object.defineProperty(exports, "FileLink", { enumerable: true, get: function () { return FileLink_2.FileLink; } });
+var ImageLink_2 = require("./ImageLink");
+Object.defineProperty(exports, "ImageLink", { enumerable: true, get: function () { return ImageLink_2.ImageLink; } });
+var LinkContent_2 = require("./LinkContent");
+Object.defineProperty(exports, "LinkContent", { enumerable: true, get: function () { return LinkContent_2.LinkContent; } });
+exports.BROKEN_CUSTOM_TYPE = "broken_type";
+exports.is = {
+    documentLink: DocumentLink_1.isDocumentLink,
+    fileLink: FileLink_1.isFileLink,
+    externalLink: ExternalLink_1.isExternalLink,
+    imageLink: ImageLink_1.isImageLink,
+};
+exports.LinksTypes = {
+    DocumentLink: DocumentLink_1.DocumentLinkType,
+    FileLink: FileLink_1.FileLinkType,
+    ExternalLink: ExternalLink_1.ExternalLinkType,
+    ImageLink: ImageLink_1.ImageLinkType,
+    LinkContent: LinkContent_1.LinkContentType,
+};

package/lib/documents/widgets/nestable/SeparatorContent.d.ts

@@ -0,0 +1,7 @@
+export declare const SeparatorContentType = "SeparatorContent";
+export declare type SeparatorContent = {
+    __TYPE__: typeof SeparatorContentType;
+};
+export declare const SeparatorContent: {
+    is(value: unknown): value is SeparatorContent;
+};

package/lib/documents/widgets/nestable/SeparatorContent.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeparatorContent = exports.SeparatorContentType = void 0;
+exports.SeparatorContentType = "SeparatorContent";
+exports.SeparatorContent = {
+    is(value) {
+        const asFieldContent = value;
+        return asFieldContent.__TYPE__ === "SeparatorContent";
+    },
+};