@monkeyplus/flow 1.1.9 → 3.0.2

package/types/flow.d.ts

@@ -0,0 +1,128 @@
+import {
+  OptionsPage,
+  OptionsLocalPage,
+  BlogInfo,
+  LevelOptions,
+  PageInfo
+} from '@monkeyplus/flow-core';
+import {
+  RouteOptions,
+  ServerRoute,
+  Request,
+  ResponseToolkit
+} from '@hapi/hapi';
+
+export interface FlowOptions {
+  relativeTo: string;
+  outputDir?: string;
+  routeOptions?: RouteOptions;
+  dirTemplates?: string;
+}
+
+export interface GenerateFolder {
+  prefix: string;
+  relativeTo: string;
+  dirs: string[];
+  override?: Record<string, string>;
+  type?: string;
+}
+export namespace Flow {
+  interface Url {
+    url: string;
+    locale: string;
+    name: string;
+    originalName: string;
+  }
+  export type Urls = Record<string, Url>;
+  export type Pages = Record<string, ServerRoute>;
+  export type Redirects = Record<string, string>;
+  export type Truncates = Record<string, string>;
+  export type DynamicContent = Record<string, { path: string; page: PageInfo }>;
+  export type DynamicPages = Record<string, string[]>;
+
+  export interface AppState {
+    redirects: Redirects;
+    urls: Urls;
+    pages: Pages;
+    truncates: Truncates;
+    dynamicPages: DynamicPages;
+  }
+  export interface Configs extends FlowOptions {
+    relativeTo: string;
+    locales: string[];
+    defaultUbication: string;
+    defaultLanguage: string;
+    publicPath: string;
+    locale: string;
+    url: string;
+    // redirects: {};
+  }
+  export interface GenerateOptions {
+    assets?: GenerateFolder[];
+    ommitAssets?: string[];
+  }
+
+  export interface Decorate {
+    init: (proxy?: boolean) => Promise<void>;
+    addPage: (page: RunDefinePage | OptionsHapiPage) => Promise<void>;
+    getPath: (...path: string[]) => string;
+    runGenerate: (options?: GenerateOptions) => Promise<void>;
+  }
+  export interface HandlerOptions {
+    name: string;
+    locale?: string;
+    view: {
+      template: string;
+      bundle?: string;
+    };
+    context?: RunContextHapi;
+    content?: string;
+  }
+}
+
+export interface OptionsHapiLocalPage extends OptionsLocalPage {
+  url: string;
+  blogInfo?: BlogInfo;
+  options?: RouteOptions;
+  rules?: Record<string, unknown>;
+  context?: RunContextHapi;
+  vhost?: string | string[];
+}
+interface Context {
+  req: Request;
+  h: ResponseToolkit;
+  page: {
+    level: string;
+    name: string;
+    locale: string;
+    template: string;
+    bundle: string;
+    publicPath: string;
+    path: string;
+  };
+  /**
+   * Si la genoracion de paginas es dinamica este es el contenido
+   */
+  dataContent: any;
+  utils: {
+    getLocalUrl: (name: string) => string;
+    getUrl: (locale: string, name: string) => string;
+  };
+}
+
+export type RunContextHapi = (ctx: Context) => Promise<any>;
+
+export interface OptionsHapiPage extends OptionsPage {
+  options?: RouteOptions;
+  context?: RunContextHapi;
+  locales: Record<string, OptionsHapiLocalPage>;
+  rules?: Record<string, unknown>;
+  vhost?: string | string[];
+}
+
+export type RunDefinePage = (configs: Flow.Configs) => ServerRoute[];
+export type RunPreDefinePage = (level?: LevelOptions) => RunDefinePage;
+export type DefinePage = (
+  page: OptionsHapiPage,
+  extensions?: { content?: string; [key: string]: any }
+) => RunPreDefinePage;

package/types/index.d.ts

@@ -1,176 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  PageInfo,
-  OptionsPage,
-  OptionsLocalPage,
-  CtxBuildLocal,
-  CtxBuildGlobal,
-  RunContext,
-  DictionaryImagesSeo,
-  ExtraOptions,
-  BlogInfo,
-  LocalesUrl
-} from '@monkeyplus/flow-core';
-import { Dictionary } from 'ramda';
-import { Lifecycle, RouteOptions, Server, ServerRoute } from '@hapi/hapi';
-import { Options } from 'prettier';
-export interface AppObject {
-  images: DictionaryImagesSeo;
-  // defaultUbication: string;
-  // defaultLanguage: string;
-  // publicPath: string;
-  domain: string;
-  locale: string;
-  locales: string[];
-  pages: Map<string, PageInfo>;
-  // routes: Dictionary<any>;
-  localePages: Dictionary<any>;
-  // globalData: Dictionary<any>;
-  // pathImages: string;
-  // pathAssets: string;
-  // // robots: {
-  // //   dissallowPaths?: string[];
-  // //   allowPaths?: string[];
-  // // };
-  prevRoutes: Map<string, ResultPage>;
-}
 
-export interface OptionsHapiLocalPage extends OptionsLocalPage {
-  url: string;
-  blogInfo?: BlogInfo;
-  routeOptions?: RouteOptions;
-  rules?: Record<string, unknown>;
-  context?: RunContextHapi;
-
-  vhost?: string | string[];
-}
-export interface CtxHapiBuildLocal extends CtxBuildLocal {
-  server: Server;
-  isStatic?: boolean;
-  shared: any;
-  sharedLocale: any;
-  page: PageInfo;
-}
-export interface CtxHapiBuilGlobal extends CtxBuildGlobal {
-  server: Server;
-  isStatic?: boolean;
-}
-
-export type RunContextHapi<CTX = any> = RunContext<CtxHapiBuildLocal, CTX>;
-export interface OptionsHapiPage extends OptionsPage {
-  routeOptions?: RouteOptions;
-  context: RunContextHapi;
-  locales: Dictionary<OptionsHapiLocalPage>;
-  rules?: Record<string, unknown>;
-  vhost?: string | string[];
-}
-
-/**
- *
- */
-interface DefaultLocale {
-  language: string;
-  ubication: string;
-  publicPath?: string;
-}
-export interface ResultPage {
-  name: string;
-  routes: (
-    ctx: CtxHapiBuildLocal,
-    handler: Lifecycle.Method
-  ) => Promise<ServerRoute[]>;
-  pages: PageInfo[];
-}
-
-export type RunDefinePage = (
-  server: Server,
-  defs: DefaultLocale,
-  locales: string[],
-  runGlobal?: RunDefineGlobalContext
-) => Promise<ResultPage>;
-
-export type PreRunDefinePage<T = RunDefinePage> = (
-  extOpts?: ExtraOptions,
-  prefixName?: string
-) => T;
-export type DefinePage = (options: OptionsHapiPage) => PreRunDefinePage;
-
-export interface ResultPage2 {
-  name: string;
-  options: OptionsHapiPage;
-  pages: PageInfo[];
-}
-
-export type RunDefinePage2 = (
-  server: Server,
-  defs: DefaultLocale,
-  locales: string[]
-) => Promise<ResultPage2>;
-
-export type DefinePage2 = (
-  options: OptionsHapiPage
-) => PreRunDefinePage<RunDefinePage2>;
-
-/**
- *
- */
-export interface OptionsInfo {
-  locale: string;
-  name: string;
-  path: string;
-  view?: {
-    template: string;
-    bundle?: string;
-  };
-}
-export interface Flow {
-  init: (proxy?: boolean) => Promise<void>;
-  addPage: (page: RunDefinePage | OptionsHapiPage) => Promise<void>;
-  defineInfoPage: (
-    options: OptionsInfo
-  ) => Promise<{ path: string; flow: PageInfo }>;
-  getPath: (...path: string[]) => string;
-  runGenerate: () => Promise<void>;
-}
-
-export type GetUrl = (
-  server: Server,
-  options: R.Dictionary<OptionsHapiLocalPage>,
-  def: string
-) => (locale: string) => Promise<LocalesUrl>;
-export type UrlPromise = (
-  locale: string,
-  name: string
-) => Promise<{ url: string; seo: any; [key: string]: any }>;
-/**
- *
- */
-export type RunDefineGlobalContext = (ctx: CtxHapiBuildLocal) => Promise<any>;
-export type DefineGlobalContext = (options: {
-  shared: RunContextHapi;
-  locales?: Dictionary<RunContextHapi>;
-}) => RunDefineGlobalContext;
-
-export interface FlowConfigs {
-  relativeTo: string;
-  locales: string[];
-  defaultUbication: string;
-  defaultLanguage: string;
-  domain: string;
-  publicPath: string;
-  sourceImagesDir: string;
-  dictionaryImages: string;
-  assetsDir: string;
-  assetsImagesDir: string;
-  sourceRename: string;
-  images: {
-    sources: string;
-    dirJsons: string;
-  };
-  server: {
-    watch: number;
-    dev: number;
-  };
-  vue: Record<string, string>;
-  // redirects: {};
-}
+export {
+  Flow,
+  FlowOptions,
+  RunDefinePage,
+  RunPreDefinePage,
+  DefinePage,
+  OptionsHapiPage,
+  GenerateFolder
+} from './flow';
+export type GenerateOptions =
+  | boolean
+  | string
+  | { isAsset: boolean; file: string; type?: string; isRemane?: boolean };