@platformos/platformos-check-common 0.0.2

package/dist/types/schema-prop-factory.d.ts

@@ -0,0 +1,76 @@
+export type Schema = {
+    [key: string]: SchemaProp<any>;
+};
+export type SchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export type SettingValue<T extends SchemaProp<any>> = T extends SchemaProp<infer U> ? U : never;
+export type Settings<S extends Schema> = {
+    [K in keyof S]: SettingValue<S[K]>;
+};
+export interface SchemaPropOptions<T> {
+    type: SchemaType;
+    defaultValue?: T;
+    optional?: boolean;
+    properties?: Schema;
+    itemType?: SchemaProp<any>;
+}
+export declare class SchemaProp<T> {
+    options: SchemaPropOptions<T>;
+    constructor(options: SchemaPropOptions<T>);
+    /** Creates a string setting definition */
+    static string(defaultValue?: string): SchemaProp<string>;
+    /** Creates a number setting definition */
+    static number(defaultValue?: number): SchemaProp<number>;
+    /** Creates a boolean setting definition */
+    static boolean(defaultValue?: boolean): SchemaProp<boolean>;
+    /**
+     * Creates an object setting definition
+     *
+     * Usage:
+     * ```
+     * const schema = {
+     *   user: SchemaProp.object({
+     *     age: SchemaProp.number(),
+     *     name: SchemaProp.string(),
+     *   })
+     * };
+     * ```
+     *
+     * @returns a schema property definition for an object type
+     */
+    static object<S extends Schema>(
+    /** The schema of the object's properties */
+    properties: S, defaultValue?: Settings<S>): SchemaProp<Settings<S>>;
+    /**
+     * Creates an array setting definition
+     *
+     * Usage:
+     * ```
+     * const schema = {
+     *   numbers: SchemaProp.array(SchemaProp.number(), [0, 1]),
+     *   strings: SchemaProp.array(SchemaProp.string(), ["foo", "bar"]),
+     *   users: SchemaProp.array(SchemaProp.object({
+     *    name: SchemaProp.string(),
+     *    age: SchemaProp.number(),
+     *   })),
+     * };
+     * ```
+     *
+     * @param itemType the type of the items in the array
+     * @returns a schema property definition for an object type
+     */
+    static array<SP extends SchemaProp<any>>(
+    /** The schema prop type of the items in the array */
+    itemType: SP, defaultValue?: Array<SettingValue<SP>>): SchemaProp<Array<SettingValue<SP>>>;
+    /**
+     * A schema prop can be optional, making the setting T | undefined.
+     *
+     * Usage:
+     * ```
+     * const Schema = {
+     *   age: SchemaProp.number().optional(),
+     * }
+     * ```
+     */
+    optional(): SchemaProp<T | undefined>;
+    defaultValue(): T | undefined;
+}

package/dist/types/schema-prop-factory.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaProp = void 0;
+class SchemaProp {
+    constructor(options) {
+        this.options = options;
+    }
+    /** Creates a string setting definition */
+    static string(defaultValue) {
+        return new SchemaProp({ type: 'string', defaultValue });
+    }
+    /** Creates a number setting definition */
+    static number(defaultValue) {
+        return new SchemaProp({ type: 'number', defaultValue });
+    }
+    /** Creates a boolean setting definition */
+    static boolean(defaultValue) {
+        return new SchemaProp({ type: 'boolean', defaultValue });
+    }
+    /**
+     * Creates an object setting definition
+     *
+     * Usage:
+     * ```
+     * const schema = {
+     *   user: SchemaProp.object({
+     *     age: SchemaProp.number(),
+     *     name: SchemaProp.string(),
+     *   })
+     * };
+     * ```
+     *
+     * @returns a schema property definition for an object type
+     */
+    static object(
+    /** The schema of the object's properties */
+    properties, defaultValue) {
+        const schema = new SchemaProp({ type: 'object', defaultValue, properties });
+        return schema;
+    }
+    /**
+     * Creates an array setting definition
+     *
+     * Usage:
+     * ```
+     * const schema = {
+     *   numbers: SchemaProp.array(SchemaProp.number(), [0, 1]),
+     *   strings: SchemaProp.array(SchemaProp.string(), ["foo", "bar"]),
+     *   users: SchemaProp.array(SchemaProp.object({
+     *    name: SchemaProp.string(),
+     *    age: SchemaProp.number(),
+     *   })),
+     * };
+     * ```
+     *
+     * @param itemType the type of the items in the array
+     * @returns a schema property definition for an object type
+     */
+    static array(
+    /** The schema prop type of the items in the array */
+    itemType, defaultValue) {
+        const schema = new SchemaProp({ type: 'array', defaultValue, itemType });
+        return schema;
+    }
+    /**
+     * A schema prop can be optional, making the setting T | undefined.
+     *
+     * Usage:
+     * ```
+     * const Schema = {
+     *   age: SchemaProp.number().optional(),
+     * }
+     * ```
+     */
+    optional() {
+        this.options.optional = true;
+        return this;
+    }
+    defaultValue() {
+        return this.options.defaultValue;
+    }
+}
+exports.SchemaProp = SchemaProp;
+//# sourceMappingURL=schema-prop-factory.js.map

package/dist/types/schema-prop-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-prop-factory.js","sourceRoot":"","sources":["../../src/types/schema-prop-factory.ts"],"names":[],"mappings":";;;AAoBA,MAAa,UAAU;IAGrB,YAAY,OAA6B;QACvC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,0CAA0C;IAC1C,MAAM,CAAC,MAAM,CAAC,YAAqB;QACjC,OAAO,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,0CAA0C;IAC1C,MAAM,CAAC,MAAM,CAAC,YAAqB;QACjC,OAAO,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,2CAA2C;IAC3C,MAAM,CAAC,OAAO,CAAC,YAAsB;QACnC,OAAO,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,MAAM;IACX,4CAA4C;IAC5C,UAAa,EACb,YAA0B;QAE1B,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC,CAAC;QAC5E,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,KAAK;IACV,qDAAqD;IACrD,QAAY,EACZ,YAAsC;QAEtC,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,CAAC;QACzE,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACH,QAAQ;QACN,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;QAC7B,OAAO,IAA4C,CAAC;IACtD,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;IACnC,CAAC;CACF;AA3FD,gCA2FC"}

package/dist/types/schemas/index.d.ts

@@ -0,0 +1,5 @@
+export { ThemeBlock } from './theme-block';
+export { Section } from './section';
+export { Setting } from './setting';
+export { Preset } from './preset';
+export { Template } from './template';

package/dist/types/schemas/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Setting = void 0;
+var setting_1 = require("./setting");
+Object.defineProperty(exports, "Setting", { enumerable: true, get: function () { return setting_1.Setting; } });
+//# sourceMappingURL=index.js.map

package/dist/types/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/schemas/index.ts"],"names":[],"mappings":";;;AAEA,qCAAoC;AAA3B,kGAAA,OAAO,OAAA"}

package/dist/types/schemas/preset.d.ts

@@ -0,0 +1,38 @@
+import { Setting } from './setting';
+export declare namespace Preset {
+    type Preset = {
+        name: string;
+        settings?: Setting.Values;
+        blocks?: PresetBlockHash;
+        block_order?: string[];
+    } | {
+        name: string;
+        settings?: Setting.Values;
+        blocks?: PresetBlockForArray[];
+    } | {
+        name: string;
+        settings?: Setting.Values;
+    };
+    type PresetBlockBase = {
+        type: string;
+        settings?: Setting.Values;
+        static?: boolean;
+        blocks?: PresetBlockHash | PresetBlockForArray[];
+    };
+    type PresetBlockForHash = PresetBlockBase & {
+        block_order?: string[];
+    };
+    type PresetBlockForArray = PresetBlockBase & {
+        id?: string;
+    };
+    type PresetBlockHash = {
+        [id: string]: PresetBlockForHash;
+    };
+    /** Base type for presets */
+    type BlockPresetBase = {
+        /** Refers to a block type. blocks/{type}.liquid */
+        type: string;
+        settings?: Setting.Values;
+    };
+    type Block = (PresetBlockForHash | PresetBlockForArray);
+}

package/dist/types/schemas/preset.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=preset.js.map

package/dist/types/schemas/preset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset.js","sourceRoot":"","sources":["../../../src/types/schemas/preset.ts"],"names":[],"mappings":""}

package/dist/types/schemas/section.d.ts

@@ -0,0 +1,49 @@
+import { Setting } from './setting';
+import { Preset } from './preset';
+export declare namespace Section {
+    /** {% schema %} */
+    interface Schema {
+        name?: string;
+        tag?: 'article' | 'aside' | 'div' | 'footer' | 'header' | 'section';
+        class?: string;
+        limit?: number;
+        settings?: Setting.Any[];
+        max_blocks?: number;
+        blocks?: Block[];
+        presets?: Preset.Preset[];
+        default?: Default;
+        locales?: Record<string, Record<string, string>>;
+        enabled_on?: SectionToggle;
+        disabled_on?: SectionToggle;
+    }
+    type Block = ThemeBlock | AppBlock | SpecificThemeBlock | LocalBlock;
+    type ThemeBlock = {
+        type: '@theme';
+    };
+    type AppBlock = {
+        type: '@app';
+    };
+    type SpecificThemeBlock = {
+        type: string;
+        limit?: number;
+        template?: string;
+    };
+    type LocalBlock = {
+        type: string;
+        name: string;
+        settings?: Setting.Any[];
+    };
+    type DefaultBlock = {
+        type: string;
+        settings?: Record<string, string | number | boolean | string[]>;
+    };
+    interface Default {
+        settings?: Record<string, string | number | boolean | string[]>;
+        blocks?: Array<DefaultBlock>;
+    }
+    interface SectionToggle {
+        templates?: TemplateType[];
+        groups?: string[];
+    }
+    type TemplateType = '*' | '404' | 'article' | 'blog' | 'captcha' | 'cart' | 'collection' | 'customers/account' | 'customers/activate_account' | 'customers/addresses' | 'customers/login' | 'customers/order' | 'customers/register' | 'customers/reset_password' | 'gift_card' | 'index' | 'list-collections' | 'metaobject' | 'page' | 'password' | 'policy' | 'product' | 'search';
+}

package/dist/types/schemas/section.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=section.js.map

package/dist/types/schemas/section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"section.js","sourceRoot":"","sources":["../../../src/types/schemas/section.ts"],"names":[],"mappings":""}

package/dist/types/schemas/setting.d.ts

@@ -0,0 +1,216 @@
+export declare namespace Setting {
+    /** Setting values are  */
+    type Values = Record<string, string | number | boolean | string[]>;
+    /** Union type of all setting types */
+    type Any = InputSetting | SideBarSetting;
+    /** Settings used for display */
+    type SideBarSetting = Header | Paragraph;
+    /** Settings with data */
+    type InputSetting = Article | Blog | Collection | Page | Product | CollectionList | ProductList | MetaobjectList | Text | Textarea | Richtext | InlineRichtext | Html | Url | TextAlignment | Number | Range | Checkbox | Radio | Select | Color | ColorBackground | ColorScheme | ColorSchemeGroup | ImagePicker | Video | VideoUrl | FontPicker | LinkList | Liquid | Metaobject | StyleLayoutPanel | StyleSizePanel | StyleSpacingPanel;
+    enum Type {
+        Article = "article",
+        Blog = "blog",
+        Collection = "collection",
+        Page = "page",
+        Product = "product",
+        CollectionList = "collection_list",
+        ProductList = "product_list",
+        MetaobjectList = "metaobject_list",
+        Text = "text",
+        Textarea = "textarea",
+        Richtext = "richtext",
+        InlineRichtext = "inline_richtext",
+        Html = "html",
+        Url = "url",
+        TextAlignment = "text_alignment",
+        Number = "number",
+        Range = "range",
+        Checkbox = "checkbox",
+        Radio = "radio",
+        Select = "select",
+        Color = "color",
+        ColorBackground = "color_background",
+        ColorScheme = "color_scheme",
+        ColorSchemeGroup = "color_scheme_group",
+        ImagePicker = "image_picker",
+        Video = "video",
+        VideoUrl = "video_url",
+        FontPicker = "font_picker",
+        LinkList = "link_list",
+        Liquid = "liquid",
+        Metaobject = "metaobject",
+        StyleLayoutPanel = "style.layout_panel",
+        StyleSizePanel = "style.size_panel",
+        StyleSpacingPanel = "style.spacing_panel",
+        Header = "header",
+        Paragraph = "paragraph"
+    }
+    interface Base<T extends Type> {
+        type: T;
+        id: string;
+        label?: string;
+        info?: string;
+    }
+    interface Header extends Base<Type.Header> {
+        content: string;
+    }
+    interface Paragraph extends Base<Type.Paragraph> {
+        content: string;
+    }
+    interface Resource<T extends Type> extends Base<T> {
+        default?: string;
+    }
+    interface Article extends Resource<Type.Article> {
+    }
+    interface Blog extends Resource<Type.Blog> {
+    }
+    interface Collection extends Resource<Type.Collection> {
+    }
+    interface Page extends Resource<Type.Page> {
+    }
+    interface Product extends Resource<Type.Product> {
+    }
+    interface ResourceList<T extends Type> extends Base<T> {
+        limit?: number;
+    }
+    interface CollectionList extends ResourceList<Type.CollectionList> {
+    }
+    interface ProductList extends ResourceList<Type.ProductList> {
+    }
+    interface MetaobjectList extends ResourceList<Type.MetaobjectList> {
+        metaobject_type: string;
+    }
+    interface TextBase<T extends Type> extends Base<T> {
+        default?: string;
+        placeholder?: string;
+    }
+    interface Text extends TextBase<Type.Text> {
+    }
+    interface Textarea extends TextBase<Type.Textarea> {
+    }
+    interface Richtext extends TextBase<Type.Richtext> {
+    }
+    interface InlineRichtext extends TextBase<Type.InlineRichtext> {
+    }
+    interface Html extends TextBase<Type.Html> {
+    }
+    interface Url extends TextBase<Type.Url> {
+    }
+    interface TextAlignment extends Base<Type.TextAlignment> {
+        default?: 'left' | 'center' | 'right' | 'justify';
+    }
+    interface NumberBase<T extends Type> extends Base<T> {
+        default?: number;
+        min?: number;
+        max?: number;
+        step?: number;
+        unit?: string;
+    }
+    interface Number extends NumberBase<Type.Number> {
+    }
+    interface Range extends NumberBase<Type.Range> {
+    }
+    interface Checkbox extends Base<Type.Checkbox> {
+        default?: boolean;
+    }
+    interface ChoiceOption {
+        value: string;
+        label: string;
+    }
+    interface ChoiceBase<T extends Type> extends Base<T> {
+        options: ChoiceOption[];
+        default?: string;
+    }
+    interface Radio extends ChoiceBase<Type.Radio> {
+    }
+    interface Select extends ChoiceBase<Type.Select> {
+    }
+    interface ColorBase<T extends Type> extends Base<T> {
+        default?: string;
+    }
+    interface Color extends ColorBase<Type.Color> {
+    }
+    interface ColorBackground extends ColorBase<Type.ColorBackground> {
+    }
+    interface ColorScheme extends Base<Type.ColorScheme> {
+        default?: string;
+    }
+    interface ColorSchemeGroup extends Base<Type.ColorSchemeGroup> {
+    }
+    interface ImagePicker extends Base<Type.ImagePicker> {
+        default?: string;
+    }
+    interface Video extends Base<Type.Video> {
+        default?: string;
+    }
+    interface VideoUrl extends Base<Type.VideoUrl> {
+        default?: string;
+        accept: Array<'youtube' | 'vimeo'>;
+    }
+    interface FontPicker extends Base<Type.FontPicker> {
+        default?: string;
+    }
+    interface LinkList extends Base<Type.LinkList> {
+        default?: string;
+    }
+    interface Liquid extends Base<Type.Liquid> {
+        default?: string;
+    }
+    interface Metaobject extends Base<Type.Metaobject> {
+        metaobject_type: string;
+    }
+    interface StyleLayoutPanel extends Base<Type.StyleLayoutPanel> {
+        default?: {
+            'flex-direction'?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
+            'flex-wrap'?: 'nowrap' | 'wrap' | 'wrap-reverse';
+            'justify-content'?: 'flex-start' | 'flex-end' | 'start' | 'end' | 'left' | 'right' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+            'align-items'?: 'stretch' | 'flex-start' | 'start' | 'self-start' | 'flex-end' | 'end' | 'self-end' | 'center' | 'baseline';
+            'align-content'?: 'stretch' | 'flex-start' | 'start' | 'flex-end' | 'end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+            gap?: string;
+            'row-gap'?: string;
+            'column-gap'?: string;
+            '@media (--mobile)'?: Partial<StyleLayoutPanel['default']>;
+        };
+    }
+    interface StyleSizePanel extends Base<Type.StyleSizePanel> {
+        default?: {
+            width?: string;
+            'min-width'?: string;
+            'max-width'?: string;
+            height?: string;
+            'min-height'?: string;
+            'max-height'?: string;
+            'flex-grow'?: string;
+            'flex-shrink'?: string;
+            'flex-basis'?: string;
+            '@media (--mobile)'?: Partial<StyleSizePanel['default']>;
+        };
+    }
+    interface StyleSpacingPanel extends Base<Type.StyleSpacingPanel> {
+        default?: {
+            padding?: string;
+            'padding-top'?: string;
+            'padding-right'?: string;
+            'padding-bottom'?: string;
+            'padding-left'?: string;
+            'padding-block'?: string;
+            'padding-block-start'?: string;
+            'padding-block-end'?: string;
+            'padding-inline'?: string;
+            'padding-inline-start'?: string;
+            'padding-inline-end'?: string;
+            margin?: string;
+            'margin-top'?: string;
+            'margin-right'?: string;
+            'margin-bottom'?: string;
+            'margin-left'?: string;
+            'margin-block'?: string;
+            'margin-block-start'?: string;
+            'margin-block-end'?: string;
+            'margin-inline'?: string;
+            'margin-inline-start'?: string;
+            'margin-inline-end'?: string;
+            '@media (--mobile)'?: Partial<StyleSpacingPanel['default']>;
+        };
+    }
+}

package/dist/types/schemas/setting.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=setting.js.map

package/dist/types/schemas/setting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setting.js","sourceRoot":"","sources":["../../../src/types/schemas/setting.ts"],"names":[],"mappings":""}

package/dist/types/schemas/template.d.ts

@@ -0,0 +1,30 @@
+import { Setting } from './setting';
+export declare namespace Template {
+    interface Template {
+        layout?: string | false;
+        wrapper?: string;
+        sections: Record<string, Template.Section>;
+        order: string[];
+    }
+    interface Section {
+        type: string;
+        settings?: Setting.Values;
+        disabled?: boolean;
+        blocks?: Record<string, Template.Block>;
+        block_order?: string[];
+    }
+    interface Block {
+        type: string;
+        settings?: Setting.Values;
+        disabled?: boolean;
+        blocks?: Record<string, Template.Block>;
+        block_order?: string[];
+        static?: boolean;
+    }
+    interface SectionGroup {
+        type: string;
+        name: string;
+        sections: Record<string, Template.Section>;
+        order: string[];
+    }
+}

package/dist/types/schemas/template.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=template.js.map

package/dist/types/schemas/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/types/schemas/template.ts"],"names":[],"mappings":""}

package/dist/types/schemas/theme-block.d.ts

@@ -0,0 +1,24 @@
+import { Setting } from './setting';
+import { Preset } from './preset';
+export declare namespace ThemeBlock {
+    /** Typed content of {% schema %} after passing validation */
+    interface Schema {
+        name?: string;
+        settings?: Setting.Any[];
+        blocks?: Block[];
+        presets?: Preset.Preset[];
+        class?: string;
+        tag?: string | null;
+    }
+    type ThemeBlock = {
+        type: '@theme';
+    };
+    type AppBlock = {
+        type: '@app';
+    };
+    type SpecificThemeBlock = {
+        /** blocks/{type}.liquid */
+        type: string;
+    };
+    type Block = (ThemeBlock | AppBlock | SpecificThemeBlock);
+}

package/dist/types/schemas/theme-block.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=theme-block.js.map

package/dist/types/schemas/theme-block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-block.js","sourceRoot":"","sources":["../../../src/types/schemas/theme-block.ts"],"names":[],"mappings":""}